C++博客-Mato is No.1-随笔分类-NOI

NOI2013 题解&&总结

Mato_No1 — Sat, 20 Jul 2013 15:43:00 GMT

@import url(http://www.cppblog.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); @import url(http://www.cppblog.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); 【Day0】
不说了囧……

【Day1】
meow：
k=2：先将这N个d维向量组成一个N*d的矩阵A，则A*A^T&e1;i&e3;&e1;j&e3;(mod 2)就是向量i•向量j(mod 2)，因此问题有解当且仅当A*A^T不是全1。
随机1*N的向量v，看(v*A)*A^T是否等于v*(N*N的全1矩阵)，如果A*A^T不是全1那么期望试两次就可以得到不等的结果。（如果试了10次都是相等，就视为无解）
如果两边的乘积不等，则找到那个不等的列，设为第i列，则必然存在一个解包含向量i，枚举另一个即可。时间复杂度O(Nd)
k=3：计算(A*A^T)&e1;i&e3;&e1;j&e3;²(mod 3)，即(Σ(x_ik*x_jk))²，即Σ(x_ik1*x_ik2*x_jk1*x_jk2)(mod 3)，对每个向量构造一个d²维向量，为之前的每个向量各维两两相乘的结果，则转化为k=2的情况（只不过将mod 2改为mod 3），时间复杂度O(Nd²)，常数小一点（比如少算mod）可以卡过去。

count：
（正解需要某些很奇怪的性质，本沙茶看不出来，只会85分的）
递推，设F&e1;i&e3;&e1;j&e3;和G&e1;i&e3;&e1;j&e3;表示某层是BFS序列的&e1;i..j&e3;这一段，树的总高度和树的棵数（所求平均值即为F&e1;i&e3;&e1;j&e3; / G&e1;i&e3;&e1;j&e3;）。
则枚举k，若k满足一定条件，则F&e1;j+1&e3;&e1;k&e3;+=F&e1;i&e3;&e1;j&e3;+G&e1;i&e3;&e1;j&e3;，G&e1;j+1&e3;&e1;k&e3;+=G&e1;i&e3;&e1;j&e3;。
问题是这个“一定条件”是什么（最难搞的地方囧）
第零，BFS&e1;j+1..k&e3;这一段的各个结点在DFS序列中的位置递增（这个很显然）。
第一，BFS&e1;j+1..k&e3;这一段的各个结点在DFS序列中的位置之前都必须有在BFS&e1;i..j&e3;范围内的结点，作为它的父结点（这个也很显然）；
第二，DFS序列中，所有在BFS&e1;i..j&e3;范围内的结点的下一个位置如果不是在BFS&e1;0..i-1&e3;范围内的，就必须是BFS&e1;j+1..k&e3;范围内的，因为这表示它的第一个子结点（这个灰常难想到！！！！！！！！！！！！！！！本沙茶就挂在这里了囧……）
对于第零和第一，实际上是给出了k的上限，枚举k时不符合这个条件则退出，而第二则是给出了k的下限（所有的“下一个位置”要填满才能算）；
此外，F和G要用long double（double也会爆，不用担心精度，本沙茶当时还在如何维护平均值的问题上纠结了很久……）
这个做法是O(N³)的，但加上那些优化就可以85分了囧……
（本沙茶当时想到这个做法了，也想到了第零和第一，但木有想到第二，结果挂了……要是真得到85分，总分254，稳的rank1了……真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧……）

train：
史上最水的提交答案……整个就是个NOIP普及组难度的题……
首先分析数据就不难发现这10个点其实是一种模型：
一开始有若干元钱（用变量v 2表示）。
有若干个大块，每个大块可以选择进或者不进，如果进，就要付出一些钱，如果不进，就自动跳转到后面的某个大块。
在每个大块里有若干个（不超过25个）小块，有1或10个变量，每个小块也可以选择要或者不要，如果要，就对所有的变量各加上一个效果值（可正可负）。
目标是所有变量的绝对值之和最大（每个大块末尾会结算一次，然后将所有变量的值清零）
首先每个大块内选哪些小块可以暴力枚举，然后得到最大的总绝对值，设为val&e1;i&e3;（i为大块编号），设如果不进第i个大块，跳到的大块编号为B&e1;i&e3;，第i个大块付出的钱为V&e1;i&e3;。
而大块之间就是一个类似于01背包的模型，设F&e1;i&e3;&e1;j&e3;表示到达第i个大块（尚未作出选择）时，用掉了j元钱的最大总效果值，用F&e1;i&e3;&e1;j&e3;更新F&e1;B&e1;i&e3;&e3;&e1;j&e3;，若不超过一开始的总钱数则用F&e1;i&e3;&e1;j&e3;+val&e1;i&e3;更新F&e1;i+1&e3;&e1;j+V&e1;i&e3;&e3;，要实时保存最优决策。
输出的时候注意一下，那里面有几个点，当钱不够时会自动选择不进当前大块，木有必要作出选择了。

至此Day1完挂。

【Day2】
matrix：
矩阵乘法，十进制快速幂。没了。

penman：
比较猥琐的DP题……
重点是这个：所有的图形都可以拆成单列，一列一列地弄（本沙茶太弱了，这个都木有想起来），然后就是三维DP。
N：设F&e1;i&e3;&e1;j&e3;&e1;k&e3;&e1;st&e3;表示第i列，上下边界分别为j、k行，状态为第st个部分（第0部分为最左边一竖，第1部分为中间若干块，第2部分为最右边一竖）的最优解，计算好一列之后求出一大堆辅助值，就可以使下一列O(1)算出了。
I：设F&e1;i&e3;&e1;j&e3;&e1;k&e3;&e1;st&e3;表示第i列，上下边界分别为j、k行，状态为第st个部分（第0部分为那一竖的左边，第1部分为那一竖，第2部分为那一竖的右边）的最优解，不需要辅助值，直接求即可；
O：可以DP，但更好的办法是枚举左、右、上边界，然后扫描，说它更好是因为知道了左右边界，可以直接引出左边的N和右边的I的最优解。
具体实现的时候细节很多……真折磨人。还有要注意为节省空间，F数组要对i这一维滚动。

foodshop：
首先这是个无向环套树（关于这方面的总结见这里）
枚举开店的那条边，如果是树边，求出该边的较下结点往下的最大长度dist1，以及往其它结点的最远距离dist2，则结果即为min{dist1+x, dist2+L-x}，满足0<=x<=L，L为该边长度。dist1求法不说了，dist2分为两部分，树内的，可以转化为经典DP模型“树的中心点”；树外的，先求出环上的每个结点往树中走的最大长度，作为这个结点的权值，然后就转化为一个带边权和点权的环，对于每个点i，求出max{i、j距离+j的权值}（j为环上的点）的值，这个值可以通过在环上扫描的方法求出：设G&e1;i&e3;为第i个点出发，逆时针走更优的位置最远到哪里。逆时针扫描这个环，然后所有的G就可以在线性时间内求出，求出G后，对每个点分别求出其逆时针更优区与顺时针更优区内的最大值（可以在扫描过程中用线段树维护），即可解决这个问题。
如果开店的边在环上，设其两端点为i、j（i->j为逆时针方向）。很容易发现，如果在这条边上开店，则j的逆时针更优区内的所有点一定是逆时针到这个店更近，i的顺时针更优区内的所有点一定是顺时针到这个店更近，而其它的点则需要额外判断一下是顺时针更近还是逆时针更近（总判断次数为线性）。这样也可以借助线段树在扫描过程中求出每条环边的顺、逆时针更优区，从而转化为与树边的问题一样的模型。时间复杂度O(NlogN)。
不过，对于环边，还有一种更简单的做法（Orz @hza）：
二分最远距离（即结果）D，然后对于环上的所有点，找到这个环上到这个点距离大于（D-这个点树里的最大深度）的点集合（显然是连续的一段弧），对所有点的这种弧求并，如果能覆盖整个环，则最优解=D。

本沙茶Day2全暴力，只拿了暴力分……对付繁琐题的能力太弱了，代码量一大就悲剧……
（后来发现，foodshop的暴力都写疵了囧……枚举开店的边后应该用SPFA求最短路，因为删掉的可能是树边，剩下的不是树……不过数据弱，木有出现这种情况囧……）

至此NOI2013完挂。
———————————————————————————————————————————————————
【总结 && 一些感想】
从上面可以看出，本沙茶在NOI2013中使用的算法都是NOIP普及组以内难度的囧（matrix的矩阵乘法可能略高级一些，但显然也不能超过NOIP难度）……
这些算法都是本沙茶在2009年以前就搞懂的，也就是说，后4年掌握的所有算法，这次都木有用上……
最后一次NOI，竟如此富有戏剧性……居然只考普及组算法……
图论、高级数据结构、字符串、几何、数论、组合……这次都木有考，这也是NOI历史上的一个“创举”了囧……
但尽管如此，本沙茶在此次NOI中仍然暴露出了诸多问题……并不是比赛技巧问题，而是平时埋下的祸根……
想题不够灵活，找不出题目隐藏的特殊性质，特殊情况考虑不清楚，写代码速度太慢……这些都是平时不好好做题，天天颓废的结果……
因此，这次挂掉，也是理所应当的事……

遗失了过去，因此，现在后悔了…………………………………………………………………

不过，不管肿么讲，还是混进了集训队……集训队是一个新的开始，每天都面临巨大的挑战，同时每天都能得到巨大的提高……
虽然本沙茶现在很弱，应付难题的能力还远远不够，但经过这一年的训练，相信可以改变这一切，尽快脱菜……
希望这能是一个转折点。
50，12，6，4，1。

———————————————————————————————————————————————————

膜拜本次虐场神犇
@鼎爷
@xudyh
@xyz111
@hzaskywalker(FFT)
@hzhwcmhf
@zhj
@鱼丸
@sunzhouyi
以及众多虐掉count、penman、foodshop的神犇……

Mato_No1 2013-07-20 23:43 发表评论

【AHOI2013复仇】NOI2008 道路设计

Mato_No1 — Sat, 22 Sep 2012 08:21:00 GMT

原题地址
典型的二次递推/DP的题目。
首先，题目中的“不便利值”指的是某个点到根的路径上的木有被选定链覆盖的边的条数。

第一问：设F[i][0..2]分别为当子树i中结点i的状态为不参与链（0）、作为某链端点（1）、作为某链中间点（2）时，子树i中的结点到i的最小不便利值。为了得到F，需要设立G[j][k(0..2)]表示结点i的前j棵子树中，有k棵的根结点与结点i接上的最小的最大不便利值。显然，不和i接上的，状态为0、1、2都行，但不便利值要加1，而和i接上的状态只能是0或1，不加1。

问题是第二问。第二问的难点在于，当i取得最小不便利值时，i的每个子结点并非都取到最小不便利值。举个例子，结点i的最小不便利值为3，它的某个子结点j的最小不便利值为2，则当j与i接上时，子树j的内部既可以取不便利值为2的解，也可以取不便利值为3的解。所以，为了解决第二问，需要求出结点i的最小不便利值为x的解的总数。万幸的是，x的范围并不是太大，可以证明，x不会超过log₃N（下取整），也就是当N=100000时x最大为10。因此，最后仍然不会T掉。

这题的一个启示就是，在求类似于“最优解计数”的问题中，不要认为当后面的状态取得最优解时，前面的状态一定取得最优解。因此，不能只记录某状态取得最优解的个数，而要记录该状态取得每一个可行解时的个数。

代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 100010, MAXW = 11, INF = ~0U >> 2;
struct edge {
    int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, Q[MAXN], F[MAXN][3], G[MAXN][3], res1 = 0;
ll MOD, FS[MAXN][MAXW][3], S[MAXN][MAXW][3], res2 = 0;
bool vst[MAXN];
void init_d()
{
    re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; m0 = m = n;
}
void add_edge0(int a, int b)
{
    E0[m0].a = a; E0[m0].b = b; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
    E0[m0].a = b; E0[m0].b = a; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void add_edge(int a, int b)
{
    E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
    int _M; scanf("%d%d", &n, &_M); cin >> MOD; if (_M < n - 1) {res1 = res2 = -1; return;} init_d(); int a0, b0;
    re2(i, 1, n) {scanf("%d%d", &a0, &b0); add_edge0(--a0, --b0);}
}
void prepare()
{
    re(i, n) vst[i] = 0; Q[0] = 0; vst[0] = 1; int x, y;
    for (int front=0, rear=0; front<=rear; front++) {
        x = Q[front];
        for (int p=E0[x].next; p != x; p=E0[p].next) {
            y = E0[p].b;
            if (!vst[y]) {vst[y] = 1; Q[++rear] = y; add_edge(x, y);}
        }
    }
    re(i, n) if (!vst[i]) {res1 = -1; res2 = -1; return;}
}
inline int minv3(int s1, int s2, int s3)
{
    int s0 = s1 <= s2 ? s1 : s2;
    return s0 <= s3 ? s0 : s3;
}
inline int minv2(int s1, int s2)
{
    return s1 <= s2 ? s1 : s2;
}
void solve()
{
    int x, y, len, v1, v2, v01, v02; ll sum;
    rre(i, n) {
        x = Q[i]; len = 0; G[0][0] = 0; G[0][1] = G[0][2] = INF;
        for (int p=E[x].next; p != x; p=E[p].next) {
            y = E[p].b; len++;
            v1 = minv3(F[y][0], F[y][1], F[y][2]) + 1; v2 = minv2(F[y][0], F[y][1]);
            G[len][0] = v1 >= G[len - 1][0] ? v1 : G[len - 1][0];
            v01 = v1 >= G[len - 1][1] ? v1 : G[len - 1][1];
            v02 = v2 >= G[len - 1][0] ? v2 : G[len - 1][0];
            G[len][1] = minv2(v01, v02);
            v01 = v1 >= G[len - 1][2] ? v1 : G[len - 1][2];
            v02 = v2 >= G[len - 1][1] ? v2 : G[len - 1][1];
            G[len][2] = minv2(v01, v02);
        }
        re(j, 3) F[x][j] = G[len][j];
        re(j, MAXW) {S[0][j][0] = 1; S[0][j][1] = S[0][j][2] = 0;} len = 0;
        for (int p=E[x].next; p != x; p=E[p].next) {
            y = E[p].b; len++;
            re(j, MAXW) re(k, 3) {
                S[len][j][k] = 0;
                if (j) {
                    sum = 0; re(k0, 3) {sum += FS[y][j - 1][k0]; if (sum >= MOD) sum -= MOD;}
                    S[len][j][k] = (sum * S[len - 1][j][k]) % MOD;
                }
                if (k) {
                    sum = 0; re(k0, 2) {sum += FS[y][j][k0]; if (sum >= MOD) sum -= MOD;}
                    S[len][j][k] = (S[len][j][k] + sum * S[len - 1][j][k - 1]) % MOD;
                }
            }
        }
        re(j, MAXW) re(k, 3) FS[x][j][k] = S[len][j][k];
    }
    res1 = minv3(F[0][0], F[0][1], F[0][2]);
    res2 = 0; re(i, 3) if (F[0][i] == res1) res2 += FS[0][F[0][i]][i]; res2 %= MOD;
}
void pri()
{
    cout << res1 << endl << res2 << endl;
}
int main()
{
    init();
    if (!res1) prepare();
    if (!res1) solve();
    pri();
    return 0;
}

Mato_No1 2012-09-22 16:21 发表评论

【AHOI2013复仇】NOI2012 park 一种巨另类的做法

Mato_No1 — Sat, 08 Sep 2012 11:27:00 GMT

摘要: 原题地址这个算法是由本沙茶在现场使用的那个做法扩展得来的……其实AC不了，后两个点会因为常数过大而T掉……但在BZOJ上算总时间的话能AC……首先考虑树的情形。设F[i]为从点i开始，往子树i里面走，到达叶结点的期望长度，则很容易得到递推公式：F[i] = (ΣF[j] + W(i, j)) / K，其中j是i的子结... 阅读全文

Mato_No1 2012-09-08 19:27 发表评论

NOI2011团体对抗赛专帖

Mato_No1 — Thu, 28 Jul 2011 14:08:00 GMT

此帖用于记录NOI2011团体对抗赛的各版本（代码）更新情况。
————————————————————————————————————————————————————
【2011年7月28日】
目前代码框架（Program0.cpp）已经完成。
NOI2011团体对抗赛安徽队的代码名称初步定为：Docx
————————————————————————————————————————————————————
【2011年7月29日】
Docx I已经完成，代码长度（包括注释）为5368Bytes
版本说明：
（1）对优势分数G的计算为G2.1版本；
（2）启发函数还比较弱；
目前由于测评机问题，暂时无法测试，只有看晚上的练习赛了。
————————————————————————————————————————————————————
【2011年7月30日】
今天秃然发现了Docx I的一个严重错误：在判定是否有炸弹的时候把true和false弄反了，结果导致炸弹根本无法使用。
现在改掉了之后（仍然命名为Docx I），TEST结果仍然不是很理想，只能虐别人的一些初等版本，高等版本（比如那个"I Hate Zerg"的版本2）根本木有办法。
目前正在改进启发函数，争取在明天下午之前出Docx II。
————————————————————————————————————————————————————
【2011年8月1日】
真惊险！最后时刻终于找到了问题所在，并且把Docx II经最后一步改进得到的版本命名为Docx III，提交到排位赛。
最后结果……还行，第3名……只是严重怀疑有强省故意放水……
大概明天正式分组就能出来了……
————————————————————————————————————————————————————
【2011年8月2日】
分组结果已经出来，安徽队的形势还是比较有利的……

好了，在8月10日下午以前都不用再管团体对抗赛了……全力冲刺个人竞赛……
————————————————————————————————————————————————————
【2011年8月10日】
团体对抗赛最后冲刺。
今天把几个地方的系数改了一下，一些看起来很傻的决策也得到了修正。不过晚上练习赛的结果仍然很不理想……
算了，明天1/4决赛等着被血洗吧囧……

现在还有一点时间，乱搞一下吧囧……
————————————————————————————————————————————————————
【2011年8月11日】
最终结果：八强，1/4决赛中被湖南血洗

显然是一个预想之中的结果……还是应验了那句话：团体对抗赛碰到湖南就是找死……
这次，本沙茶真的已经尽力了……
明年再来吧……

Mato_No1 2011-07-28 22:08 发表评论

NOI2005 智慧珠游戏

Mato_No1 — Wed, 20 Jul 2011 15:07:00 GMT

摘要: 【原题见这里】很明显的精确覆盖的模型，12个零件，再加上它们经过旋转、翻转后的不同形状，共60种，每种又可以放在不同的位置（只看最左上的那个珠子）一种零件的一种位置就是一行。列（限制）有两种：每个格子只能放一个（55列），以及每个零件（注意是每个零件，不是每种零件）只能用一次（12列），共67列。预先放的那些零件可以看成预先选中的行。然后DLX精确覆盖即可。下面是DLX精确覆盖的几个易疵点：（1）... 阅读全文

Mato_No1 2011-07-20 23:07 发表评论

NOI2008 party

Mato_No1 — Thu, 14 Jul 2011 04:23:00 GMT

原题见这里（BZOJ和BSOJ都挂了，真杯具，只能借助RQ了囧……）

难度不是很大，就是特殊情况比较多，比较猥琐（不过本题数据弱，就算不考虑所有的特殊情况也能过7个点）。
首先O(NM)的朴素算法很好想到：枚举K，然后给每个结点编号即可。在编号时，先随便指定一个未编号的点，设它的编号为0，然后遍历所有和它相关联的边（这里可以把原图想象成一个无向图），将这些边的另一个端点编上号即可，中间若某个点的编号出现矛盾，则这个K不合法，否则这个K合法。
然后进行优化：合法的K实际上是有限制的，它必然是某个数的因数，具体来说，对这个图进行DFS，并考察其中所有的跨越边和逆向边，对于跨越边，设遍历树中i、j间距离为D，则合法的K必然是(D-1)的因数（因为i和遍历树中j的父结点都有指向j的边，它们的编号应相同，而它们之间的距离为(D-1)）；对于逆向边，设遍历树中i、j间距离为D'，则合法的K必然是(D'+1)的因数（因为这里形成了一个环，环的长度为(D'+1)）。这样一来就明显缩小了K的取值范围，再进行枚举，就可以显著缩短时间。

下面是一些极其猥琐的特殊情况：
（1）根据题意，必须是K类每类都有，因此在尝试编号成功（没有发生任何矛盾）后，还要看一下实际出现的编号数目是否等于K，若小于K，同样不合法；
（2）该图的基图可能不连通，此时对于其基图的每个连通块，其编号互不影响，所以要对每个连通块分别统计实际出现的编号数目，设它们的和为SUM，则不大于SUM的K值均合法（只要中间不出现矛盾），因此可以直接得到最大值为SUM，提前结束；不过，这种特判只有在总共实际出现的编号数目小于K的情况下才能进行；
（3）由于考察的是实际出现的编号数目，因此最后求出的最大值、最小值可能小于3，这时应作出如下处理：若最大值小于3，则无解；若最小值小于3，则将最小值改为3。

本题比较猥琐的数据是第4、5、6个点，分别出现了上述的第（1）、（2）、（3）种特殊情况，此外，这三个点建出的图中竟然没有一条跨越边或逆向边！

代码：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 100000, MAXM = 1100001;
struct edge {
    int a, b, s, pre, next;
} E0[MAXM], E[MAXM + MAXM];
int n, m0, m, P, len, X[MAXN], No[MAXN], stk[MAXN], st[MAXN], dep[MAXN], V[MAXN], fo[MAXN], Q[MAXN], res0, res1;
bool vst[MAXN], T0[MAXN];
long long T[MAXN], _Z = 0;
void init_d()
{
    re(i, n) E[i].a = E[i].pre = E[i].next = E0[i].a = E0[i].pre = E0[i].next = i;
    m0 = n; if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b)
{
    E0[m0].a = a; E0[m0].b = b; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
    E[m].a = a; E[m].b = b; E[m].s = 1; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
    E[m].a = b; E[m].b = a; E[m].s = -1; E[m].pre = E[b].pre; E[m].next = b; E[b].pre = m; E[E[m].pre].next = m++;
}
void init()
{
    freopen("party.in", "r", stdin);
    int _m, a, b; scanf("%d%d", &n, &_m); init_d();
    re(i, _m) {
        scanf("%d%d", &a, &b);
        add_edge(--a, --b);
    }
    fclose(stdin);
}
int gcd(int a, int b)
{
    int r;
    while (b) {
        r = a % b; a = b; b = r;
    }
    return a;
}
void prepare()
{
    int tp, x, y, ord = 0;
    bool fd;
    re(i, n) V[i] = 0; P = 0;
    re(i, n) if (!V[i]) {
        stk[tp = 0] = i; fo[i] = ord++; V[i] = 1; st[i] = E0[i].next; dep[i] = 0;
        while (tp >= 0) {
            x = stk[tp]; fd = 0;
            for (int p=st[x]; p != x; p=E0[p].next) {
                y = E0[p].b;
                if (!V[y]) {
                    stk[++tp] = y; fo[y] = ord++; V[y] = 1; st[y] = E0[y].next; dep[y] = dep[x] + 1; st[x] = E0[p].next; fd = 1; break;
                } else if (V[y] == 1) P = gcd(P, dep[x] - dep[y] + 1); else if (fo[y] > fo[x]) P = gcd(P, dep[y] - dep[x] - 1);
            }
            if (!fd) {V[x] = 2; tp--;}
        }
    }
    len = 0; re3(i, 3, n) if (!(P % i)) X[len++] = i;
}
int test(int K)
{
    re(i, n) {vst[i] = 0; No[i] = -1;}
    re(i, K) T0[i] = 0;
    int x, y, No0, sum = 0, sum0 = 0;
    re(i, n) if (!vst[i]) {
        No[i] = 0; Q[0] = i; vst[i] = 1; _Z++; if (T[0] != _Z) {T[0] = _Z; sum++;} if (!T0[0]) {T0[0] = 1; sum0++;}
        for (int front=0, rear=0; front<=rear; front++) {
            x = Q[front];
            for (int p=E[x].next; p != x; p=E[p].next) {
                y = E[p].b; No0 = No[x] + E[p].s;
                if (No0 == K) No0 = 0; else if (No0 == -1) No0 = K - 1;
                if (No[y] >= 0 && No0 != No[y]) return -1; else {
                    No[y] = No0;
                    if (T[No0] != _Z) {T[No0] = _Z; sum++;}
                    if (!T0[No0]) {T0[No0] = 1; sum0++;}
                }
                if (!vst[y]) {vst[y] = 1; Q[++rear] = y;}
            }
        }
    }
    if (sum0 < K) res0 = sum;
    return sum0;
}
void solve()
{
    int K, K0; res0 = res1 = -1;
    re(i, len) {
        K = X[i]; K0 = test(K);
        if (K0 != -1) {
            if (res1 == -1) res1 = K0;
            if (K0 < K) break; else res0 = K;
        }
    }
    if (res0 < 3) res0 = res1 = -1; else if (res1 < 3) res1 = 3;
}
void pri()
{
    freopen("party.out", "w", stdout);
    printf("%d %d\n", res0, res1);
    fclose(stdout);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-07-14 12:23 发表评论

【NOI2005 维护数列(sequence)】Splay Tree处理序列问题

Mato_No1 — Tue, 21 Jun 2011 08:06:00 GMT

【原题见这里】
本题是Splay Tree处理序列问题（也就是当线段树用）的一个典型例题。

Splay Tree之所以可以当线段树用，是因为它可以支持一个序列，然后用“左端前趋伸展到根，右端后继伸展到根的右子结点，取根的右子结点的左子结点”这种伸展方法，对一个序列中的一整段进行整体操作。由于要防止出现前趋或后继不存在的情况，需要在这个序列的两端加入两个边界结点，要求其值不能影响到结点各种记载信息的维护（多取0、∞或-∞）。这两个边界结点在树中永远存在，不会被删除。

（1）结点的引用：
在当线段树用的Splay Tree中，真正的关键字是下标而不是值，因此，“序列中第i个结点”实际上对应的是“树中第(i+1)小的结点”（因为左边还有一个边界结点），这就说明在对结点引用时需要找第K小的操作。因此，下面的“结点x”指的是“树中第(x+1)小的结点”。
（2）标记：
在线段树中，如果对一个结点所表示的线段整体进行了某种操作，需要在这个结点上打上一个标记，在下一次再找到这个结点时，其标记就会下放到其两个子结点上。在Splay Tree中也可以引入标记。比如要对[2, 6]这一段进行整体操作，就将结点1伸展到根的位置，将结点7伸展到根的右子树的位置，然后结点7的左子树就表示[2, 6]这一段，对这棵子树的根结点打上标记并立即生效（必须是立即生效，而不是等下一次引用再生效），也就是立即改变该结点记录的一些信息的值。如果下次再次引用到这个结点，就要将其标记下放到其两个子结点处；
需要注意的一点是，如果要伸展某个结点x到r的子结点的位置，就必须保证从x原来的位置到r的这个子结点（x伸展后的位置）上的所有结点上均没有标记，否则就会导致标记混乱。因此，必须首先找到这个结点x，在此过程中不断下放标记。
（3）自底向上维护的信息：
标记可以看成一种自顶向下维护的信息。除了标记以外，作为“线段树”，往往还要维护一些自底向上维护的信息。比如在sequence这题中，就有lmax（左段连续最大和）、rmax（右段连续最大和）、midmax（全段连续最大和）以及sum（全段总和）等信息要维护。对于这类东东其实也很好办，因为子树大小（sz域）就是一种自底向上维护的信息，因此对于这些信息只要按照维护sz域的办法维护即可（统一写在upd函数里）。唯一的不同点是打标记时它们的值可能要改变。
（4）对连续插入的结点建树：
本题的插入不是一个一个插入，而是一下子插入一整段，因此需要先将它们建成一棵树。一般建树操作都是递归的，这里也一样。设目前要对A[l..r]建树（A为待插入序列），若l>r则退出，否则找到位于中间的元素mid = l + r >> 1，将A[mid]作根，再对A[l..mid-1]建左子树，对A[mid+1..r]建右子树即可。这样可以保证一开始建的就是一棵平衡树，减小常数因子。
（5）回收空间：
根据本题的数据范围提示，插入的结点总数最多可能达到4000000，但在任何时刻树中最多只有500002个结点（包括两个边界），此时为了节省空间，可以采用循环队列回收空间的方法。即：一开始将所有的可用空间（可用下标，本题为1~500002）存在循环队列Q里，同时设立头尾指针front和rear，每次如果有新结点插入，就取出Q[front]并作为新结点的下标，如果有结点要删除（本题是一次删除整棵子树，因此在删除后需要分别回收它们的空间），则从rear开始，将每个删除的结点的下标放回到Q里。当然，这种方法是要牺牲一定的时间的，因此在空间不是特别吃紧的情况下不要用。

【2012年1月16日更新】
今天重写sequence的时候，秃然发现加入的边界点可能会对lmax、rmax、midmax等的维护造成影响：当序列中所有的值都是负数时，若边界点的值设为0，将使这3个值也为0，所以，边界点的值应设为-INF（不会影响到sum，因为可以单独调出[l, r]的sum，避开边界）。这就说明并非所有这样的题中都可以设置边界点（比如HFTSC2011的那题就不行），如果边界点会对维护的信息造成影响，就不能设置边界点，在各个操作中，分4种情况判断。（代码已经修改）

下面上代码了：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 500002, NOSM = -2000, INF = ~0U >> 2;
struct node {
    int v, c[2], p, sz, sum, lmax, rmax, midmax, sm;
    bool rev, d;
} T[MAXN + 1];
int root, Q[MAXN + 1], front, rear, a[MAXN], len, res;
int max(int SS0, int SS1)
{
    return SS0 >= SS1 ? SS0 : SS1;
}
int max(int SS0, int SS1, int SS2)
{
    int M0 = SS0 >= SS1 ? SS0 : SS1; return M0 >= SS2 ? M0 : SS2;
}
void newnode(int n, int _v)
{
    T[n].v = T[n].sum = T[n].lmax = T[n].rmax = T[n].midmax = _v; T[n].c[0] = T[n].c[1] = 0; T[n].sz = 1; T[n].sm = NOSM; T[n].rev = 0;
}
void sc(int _p, int _c, bool _d)
{
    T[_p].c[_d] = _c; T[_c].p = _p; T[_c].d = _d;
}
void sm_opr(int x, int SM)
{
    T[x].sum = T[x].sz * SM;
    if (SM > 0) T[x].lmax = T[x].rmax = T[x].midmax = T[x].sum; else T[x].lmax = T[x].rmax = T[x].midmax = SM;
}
void rev_opr(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1]; sc(x, c0, 1); sc(x, c1, 0);
    int tmp = T[x].lmax; T[x].lmax = T[x].rmax; T[x].rmax = tmp;
}
void dm(int x)
{
    int SM0 = T[x].sm;
    if (SM0 != NOSM) {
        T[x].v = T[T[x].c[0]].sm = T[T[x].c[1]].sm = SM0; T[x].sm = NOSM;
        sm_opr(T[x].c[0], SM0); sm_opr(T[x].c[1], SM0);
    }
    if (T[x].rev) {
        T[T[x].c[0]].rev = !T[T[x].c[0]].rev; T[T[x].c[1]].rev = !T[T[x].c[1]].rev; T[x].rev = 0;
        rev_opr(T[x].c[0]); rev_opr(T[x].c[1]);
    }
}
void upd(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1];
    T[x].sz = T[c0].sz + T[c1].sz + 1;
    T[x].sum = T[c0].sum + T[c1].sum + T[x].v;
    T[x].lmax = max(T[c0].lmax, T[c0].sum + T[x].v + max(T[c1].lmax, 0));
    T[x].rmax = max(T[c1].rmax, max(T[c0].rmax, 0) + T[x].v + T[c1].sum);
    T[x].midmax = max(T[c0].midmax, T[c1].midmax, max(T[c0].rmax, 0) + T[x].v + max(T[c1].lmax, 0));
}
void rot(int x)
{
    int y = T[x].p; bool d = T[x].d;
    if (y == root) {root = x; T[root].p = 0;} else sc(T[y].p, x, T[y].d);
    sc(y, T[x].c[!d], d); sc(x, y, !d); upd(y);
}
void splay(int x, int r)
{
    int p; while ((p = T[x].p) != r) if (T[p].p == r) rot(x); else if (T[x].d == T[p].d) {rot(p); rot(x);} else {rot(x); rot(x);} upd(x);
}
int Find_Kth(int K)
{
    int i = root, S0;
    while (i) {
        dm(i); S0 = T[T[i].c[0]].sz + 1;
        if (K == S0) break; else if (K < S0) i = T[i].c[0]; else {K -= S0; i = T[i].c[1];}
    }
    return i;
}
int mkt(int l, int r)
{
    if (l > r) return 0;
    int n0 = Q[front], mid = l + r >> 1; if (front == MAXN) front = 1; else front++;
    newnode(n0, a[mid]); int l_r = mkt(l, mid - 1), r_r = mkt(mid + 1, r);
    sc(n0, l_r, 0); sc(n0, r_r, 1); upd(n0); return n0;
}
void ins(int pos)
{
    int P0 = Find_Kth(pos); splay(P0, 0); int P1 = Find_Kth(pos + 1); splay(P1, root); sc(P1, mkt(0, len - 1), 0); upd(P1); upd(P0);
}
void era(int x)
{
    if (!x) return;
    if (rear == MAXN) rear = 1; else rear++; Q[rear] = x;
    era(T[x].c[0]); era(T[x].c[1]);
}
void del(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int root0 = T[P1].c[0]; sc(P1, 0, 0); upd(P1); upd(P0); era(root0);
}
void mksame(int l, int r, int x)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].sm = x; sm_opr(n, x); upd(P1); upd(P0);
}
void reve(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].rev = !T[n].rev; rev_opr(n); upd(P1); upd(P0);
}
int get_sum(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; return T[n].sum;
}
int max_sum()
{
    return T[root].midmax;
}
void prepare()
{
    T[0].sz = T[0].sum = T[0].lmax = T[0].rmax = T[0].midmax = 0;
    front = 3; rear = MAXN; re1(i, MAXN) Q[i] = i;
    newnode(1, -INF); newnode(2, -INF); sc(1, 2, 1); root = 1; T[root].p = 0;
}
int main()
{
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
    prepare();
    int m, l, r, x;
    scanf("%d%d", &len, &m); char ch = getchar(), str[1000];
    re(i, len) scanf("%d", &a[i]); ins(1);
    re(i, m) {
        scanf("%s", str);
        if (!strcmp(str, "INSERT")) {scanf("%d%d", &l, &len); re(i, len) scanf("%d", &a[i]); ins(++l);}
        if (!strcmp(str, "DELETE")) {scanf("%d%d", &l, &r); r += l++; del(l, r);}
        if (!strcmp(str, "MAKE-SAME")) {scanf("%d%d%d", &l, &r, &x); r += l++; mksame(l, r, x);}
        if (!strcmp(str, "REVERSE")) {scanf("%d%d", &l, &r); r += l++; reve(l, r);}
        if (!strcmp(str, "GET-SUM")) {scanf("%d%d", &l, &r); r += l++; printf("%d\n", get_sum(l, r));}
        if (!strcmp(str, "MAX-SUM")) printf("%d\n", max_sum());
        ch = getchar();
    }
    fclose(stdin); fclose(stdout);
    return 0;
}

最后把我的这个代码与BYVoid神犇的本题代码进行测试比较，结果（BYVoid神犇的代码见这里）：

BYVoid神犇的：

本沙茶的：

【相关论文】
运用伸展树解决数列维护问题 by JZP
【感谢】
JZP神犇（提供论文）
BYVoid神犇（提供标程）

Mato_No1 2011-06-21 16:06 发表评论

终于摘掉了不会平衡树的帽子

Mato_No1 — Sat, 18 Jun 2011 13:21:00 GMT

摘要: 今天真是有纪念意义啊……以前试着捉了N遍的cashier今天竟然AC了，本沙茶终于掌握了平衡树！！！【Splay Tree及其实现】<1>结点记录的信息：一般情况下Splay Tree是用线性存储器（结构数组）来存储的，可以避免在Linux下的指针异常问题。这样对于某个结点，至少要记录以下的域：值（又叫关键字）、左子结点的下标、右子结点的下标、父结点下标、子树大... 阅读全文

Mato_No1 2011-06-18 21:21 发表评论