久久深夜福利,亚洲第一综合天堂另类专,久久嫩草精品久久久精品一

NOI2013 题解&&�ȝ��

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

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

【Day1�?br /> meow�Q?br /> k=2�Q�先��这N个d�l�向量组成一个N*d的矩阵A�Q�则A*A^T&e1;i&e3;&e1;j&e3;(mod 2)��是向量i•向量j(mod 2)�Q�因此问题有解当且仅当A*A^T不是�?�?br /> 随机1*N的向量v�Q�看(v*A)*A^T是否�{�于v*(N*N的全1矩阵)�Q�如果A*A^T不是�?那么期望试两�ơ就可以得到不等的结果。（如果试了10�ơ都是相�{�，��p��为无解）
如果两边的乘�U�不�{�，则找到那个不�{�的列，设�ؓ�W�i列，则必然存在一个解包含向量i�Q�枚丑֏�一个即可。时间复杂度O(Nd)
k=3�Q�计��?A*A^T)&e1;i&e3;&e1;j&e3;²(mod 3)�Q�即(Σ(x_ik*x_jk))²�Q�即Σ(x_ik1*x_ik2*x_jk1*x_jk2)(mod 3)�Q�对每个向量构造一个d²�l�向量，��Z��前的每个向量各维两两�怹�的结果，则�{化�ؓk=2的情况（只不�q�将mod 2改�ؓmod 3�Q�，旉��复杂度O(Nd²)�Q�常数小一点（比如��算mod�Q�可以卡�q�去�?br />
count�Q?br /> �Q�正解需要某些很奇怪的性质�Q�本沙茶看不出来�Q�只�?5分的�Q?br /> 递推�Q�设F&e1;i&e3;&e1;j&e3;和G&e1;i&e3;&e1;j&e3;表示某层是BFS序列�?amp;e1;i..j&e3;�q�一�D�，树的总高度和树的��|��Q�所求��^均值即为F&e1;i&e3;&e1;j&e3; / G&e1;i&e3;&e1;j&e3;�Q��?br /> 则枚举k�Q�若k满��一定条�?/span>�Q�则F&e1;j+1&e3;&e1;k&e3;+=F&e1;i&e3;&e1;j&e3;+G&e1;i&e3;&e1;j&e3;�Q�G&e1;j+1&e3;&e1;k&e3;+=G&e1;i&e3;&e1;j&e3;�?br /> 问题是这�?#8220;一定条�?#8221;是什么（最难搞的地方囧�Q?br /> �W�零�Q�BFS&e1;j+1..k&e3;�q�一�D늚�各个�l�点在DFS序列中的位置递增�Q�这个很昄��Q��?br /> �W�一�Q�BFS&e1;j+1..k&e3;�q�一�D늚�各个�l�点在DFS序列中的位置之前都必��L��在BFS&e1;i..j&e3;范围内的�l�点�Q�作为它的父�l�点�Q�这个也很显�Ӟ��Q?br /> �W�二�Q�DFS序列中，所有在BFS&e1;i..j&e3;范围内的�l�点的下一个位�|�如果不是在BFS&e1;0..i-1&e3;范围内的�Q�就必须是BFS&e1;j+1..k&e3;范围内的�Q�因��表示它的�W�一个子�l�点�Q�这个灰帔R��惛_��Q�！�Q�！�Q�！�Q�！�Q�！�Q�！�Q�！�Q�本沙茶��挂在这里了�?#8230;…�Q?br /> 对于�W�零和第一�Q�实际上是给��Z��k的上限，枚�Dk时不�W�合�q�个条�g则退出，而第二则是给��Z��k的下限（所有的“下一个位�|?#8221;要填满才能算�Q�；
此外�Q�F和G要用long double�Q�double也会爆，不用担心�_�ֺ��Q�本沙茶当时�q�在如何�l�护�q�_��值的问题上纠�l�了很久……�Q?br /> �q�个做法是O(N³)的，但加上那些优化就可以85分了�?#8230;…
�Q�本沙茶当时惛_��q�个做法了，也想��C��W�零和第一�Q�但木有惛_��W�二�Q�结果挂�?#8230;…要是真得�?5分，��d��254�Q�稳的rank1�?#8230;…真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲剧，真悲�?#8230;…�Q?br />
train�Q?br /> 史上最水的提交�{�案……整个��是个NOIP普及�l�难度的�?#8230;…
首先分析数据��׃��隑֏�现这10个点其实是一�U�模型：
一开始有若干元钱�Q�用变量v 2表示�Q��?br /> 有若�q�个大块�Q�每个大块可以选择�q�或者不�q�，如果�q�，��p��付出一些钱�Q�如果不�q�，��p��动蟩转到后面的某个大块�?br /> 在每个大块里有若�q�个�Q�不��过25个）��块�Q�有1�?0个变量，每个��块也可以选择要或者不要，如果要，��对所有的变量各加上一个效果��|��可正可负�Q��?br /> 目标是所有变量的�l�对��g��和最大（每个大块末尾会结��一�ơ，然后��所有变量的值清�Ӟ��
首先每个大块内选哪些小块可以暴力枚举，然后得到最大的�ȝ��对��|��设�ؓval&e1;i&e3;�Q�i为大块编��P��Q�设如果不进�W�i个大块，跛_��的大块编号�ؓB&e1;i&e3;�Q�第i个大块付出的�׃ؓV&e1;i&e3;�?br /> 而大块之间就是一个类��g��01背包的模型，设F&e1;i&e3;&e1;j&e3;表示到达�W�i个大块（��未作出选择�Q�时�Q�用掉了j元钱的最大��L��果��|��用F&e1;i&e3;&e1;j&e3;更新F&e1;B&e1;i&e3;&e3;&e1;j&e3;�Q�若不超�q�一开始的总钱数则用F&e1;i&e3;&e1;j&e3;+val&e1;i&e3;更新F&e1;i+1&e3;&e1;j+V&e1;i&e3;&e3;�Q�要实时保存最优决�{��?br /> 输出的时候注意一下，那里面有几个点，当钱不够时会自动选择不进当前大块�Q�木有必要作出选择了�?br />
��x��Day1完挂�?br />
【Day2�?br /> matrix�Q?br /> 矩阵乘法�Q�十�q�制快速幂。没了�?br />
penman�Q?br /> 比较猥琐的DP�?#8230;…
重点是这个：所有的囑�Ş都可以拆成单列，一列一列地弄（本沙茶太�׃��Q�这个都木有惌��v来）�Q�然后就是三�l�DP�?br /> N�Q�设F&e1;i&e3;&e1;j&e3;&e1;k&e3;&e1;st&e3;表示�W�i列，上下边界分别为j、k行，状态�ؓ�W�st个部分（�W?部分为最左边一竖，�W?部分��Z��间若�q�块�Q�第2部分为最双��一竖）的最优解�Q�计��好一列之后求��Z��大堆辅助��|��可以��下一列O(1)��出了�?br /> I�Q�设F&e1;i&e3;&e1;j&e3;&e1;k&e3;&e1;st&e3;表示�W�i列，上下边界分别为j、k行，状态�ؓ�W�st个部分（�W?部分为那一竖的左边�Q�第1部分为那一竖，�W?部分为那一竖的双��Q�的最优解�Q�不需要辅助��|��直接求即可；
O�Q�可以DP�Q�但更好的办法是枚�D左、右、上边界�Q�然后扫描，说它更好是因为知道了左右边界�Q�可以直接引出左边的N和右边的I的最优解�?br /> 具体实现的时候细节很�?#8230;…真折��h。还有要注意��省空��_��F数组要对i�q�一�l�滚动�?br />
foodshop�Q?br /> 首先�q�是个无向环套树�Q�关于这斚w��的�ȝ��?a title=""�q�里"" href=""http://www.shnenglu.com/MatoNo1/archive/2012/09/01/189006.html"">�q�里�Q?br /> 枚�D开店的那条边，如果是树边，求出该边的较下结点往下的最大长度dist1�Q�以及往其它�l�点的最�q�距��dist2�Q�则�l�果即�ؓmin{dist1+x, dist2+L-x}�Q�满��?<=x<=L�Q�L��辚w��度。dist1求法不说了，dist2分�ؓ两部分，树内的，可以转化为经典DP模型“树的中心�?#8221;�Q�树外的�Q�先求出环上的每个结点往树中走的最大长度，作�ؓ�q�个�l�点的权��|��然后��p�{化�ؓ一个带�Ҏ��和点权的环，对于每个点i�Q�求出max{i、j距离+j的权值}�Q�j为环上的点）的��|��q�个值可以通过在环上扫描的�Ҏ��求出�Q�设G&e1;i&e3;为第i个点出发�Q�逆时针走更优的位�|�最�q�到哪里。逆时针扫描这个环�Q�然后所有的G��可以在�U�性时间内求出�Q�求出G后，�Ҏ��个点分别求出光��时针更优区与顺旉��更优区内的最大��|��可以在扫描过�E�中用线�D�|��l�护�Q�，卛_��解决�q�个问题�?br /> 如果开店的边在环上�Q�设其两端点为i、j�Q�i->j为逆时针方向）。很�Ҏ��发现�Q�如果在�q�条边上开店，则j的逆时针更优区内的所有点一定是逆时针到�q�个店更�q�，i的顺旉��更优区内的所有点一定是��时针到�q�个店更�q�，而其它的点则需要额外判断一下是��时针更�q�还是逆时针更�q�（��d��断次��Cؓ�U�性）。这样也可以借助�U�段树在扫描�q�程中求出每条环边的��、逆时针更优区�Q�从而�{化�ؓ与树边的问题一��L��模型。时间复杂度O(NlogN)�?br /> 不过�Q�对于环边，�q�有一�U�更��单的做法�Q�Orz @hza�Q�：
二分最�q�距��（即结果）D�Q�然后对于环上的所有点�Q�找到这个环上到�q�个点距��d��于（D-�q�个�Ҏ��里的最大深度）的点集合�Q�显然是�q�箋的一�D�弧�Q�，�Ҏ��有点的这�U�弧求�ƈ�Q�如果能覆盖整个环，则最优解=D�?br />
本沙茶Day2全暴力，只拿了暴力分……对付�J�琐题的能力太弱了，代码量一大就悲剧……
�Q�后来发玎ͼ�foodshop的暴力都写疵了囧……枚�D开店的边后应该用SPFA求最短�\�Q�因为删掉的可能是树边，剩下的不是树……不过数据弱，木有出现�q�种情况�?#8230;…�Q?br />
��x��NOI2013完挂�?br /> ———————————————————————————————————————————————————
【�ȝ�� && 一些感惟�?br /> 从上面可以看出，本沙茶在NOI2013中��用的��法都是NOIP普及�l�以内难度的囧（matrix的矩阵乘法可能略高��一些，但显然也不能��过NOIP隑ֺ��Q?#8230;…
�q�些��法都是本沙茶在2009�q�以前就搞懂的，也就是说�Q�后4�q�掌握的所有算法，�q�次都木有用�?#8230;…
最后一�ơNOI�Q�竟如此富有戏剧�?#8230;…居然只考普及组��法……
图论、高�U�数据结构、字�W�串、几何、数论、组�?#8230;…�q�次都木有考，�q�也是NOI历史上的一�?#8220;创�D”了囧……
但尽��如此，本沙茶在此次NOI中仍然暴露出了诸多问�?#8230;…�q�不是比赛技巧问题，而是�q�x��埋下的祸�?#8230;…
想题不够灉|��Q�找不出题目隐藏的特�D�性质�Q�特�D�情况考虑不清楚，写代码速度太慢……�q�些都是�q�x��不好好做题，天天颓废的结�?#8230;…
因此�Q�这�ơ挂掉，也是理所应当的事……

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

不过�Q�不��肿么讲�Q�还是�؜�q�了集训�?#8230;…集训队是一个新的开始，每天都面临巨大的挑战�Q�同时每天都能得到巨大的提高……
虽然本沙茶现在很弱，应付��N��的能力还�q�远不够�Q�但�l�过�q�一�q�的训练�Q�相信可以改变这一切，��快��p��……
希望�q�能是一个�{折点�?br /> 50�Q?2�Q?�Q?�Q?�?/span>

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

膜拜本次虐场��犇
@鼎爷
@xudyh
@xyz111
@hzaskywalker(FFT)
@hzhwcmhf
@zhj
@��g��
@sunzhouyi
以及众多虐掉count、penman、foodshop的神�?#8230;…

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

【AHOI2013复仇】NOI2008 道�\设计

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

原题地址
典型的二�ơ递推/DP的题目�?br />首先�Q�题目中�?#8220;不便利�?#8221;指的是某个点到根的�\径上的木有被选定链覆盖的边的条数�?br />
�W�一问：设F[i][0..2]分别为当子树i中结点i的状态�ؓ不参与链�Q?�Q�、作为某铄��点（1�Q�、作为某链中间点�Q?�Q�时�Q�子树i中的�l�点到i的最��不便利倹{��ؓ了得到F�Q�需要设立G[j][k(0..2)]表示�l�点i的前j��子树中�Q�有k��늚�根结点与�l�点i接上的最��的最大不便利倹{��显�Ӟ��不和i接上的，状态�ؓ0�?�?都行�Q�但不便利��D��?�Q�而和i接上的状态只能是0�?�Q�不�?�?br />
问题是第二问。第二问的难点在于，当i取得最��不便利值时�Q�i的每个子�l�点�q��都取到最��不便利�?/strong>。�D个例子，�l�点i的最��不便利��gؓ3�Q�它的某个子�l�点j的最��不便利��gؓ2�Q�则当j与i接上�Ӟ��子树j的内部既可以取不便利��gؓ2的解�Q�也可以取不便利��gؓ3的解。所以，��Z��解决�W�二问，需要求出结点i的最��不便利��gؓx的解的��L��?strong>万幸的是�Q�x的范围�ƈ不是太大�Q�可以证明，x不会��过log₃N�Q�下取整�Q�，也就是当N=100000时x最大�ؓ10�?/span>因此�Q�最后仍然不会T掉�?br />
�q�题的一个启�C�就是，在求�c�M��?#8220;最优解计数”的问题中�Q?span style="color: red">不要认�ؓ当后面的状态取得最优解�Ӟ��前面的状态一定取得最优解�?/strong>因此�Q�不能只记录某状态取得最优解的个敎ͼ�而要记录该状态取得每一个可行解时的个数�?br />
代码�Q?
#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 发表评论

Mato_No1 — Sat, 08 Sep 2012 11:27:00 GMT
     摘要: 原题地址�q�个��法是由本沙茶在现场使用的那个做法扩展得来的……其实AC不了�Q�后两个点会因�ؓ常数�q�大而T�?#8230;…但在BZOJ上算��L��间的话能AC……首先考虑树的情�Ş。设F[i]��Z��点i开始，往子树i里面赎ͼ�到达叶结点的期望长度�Q�则很容易得到递推公式�Q�F[i] = (ΣF[j] + W(i, j)) / K�Q�其中j是i的子�l?..  阅读全文

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

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

此帖用于记录NOI2011团体�Ҏ��赛的各版本（代码�Q�更新情��c�?br />————————————————————————————————————————————————————
�?011�q?�?8日�?br />目前代码框架�Q�Program0.cpp�Q�已�l�完成�?br />NOI2011团体�Ҏ��赛安徽队的代码名�U�初步定为：Docx
————————————————————————————————————————————————————
�?011�q?�?9日�?br />Docx I已经完成�Q�代码长度（包括注释�Q��ؓ5368Bytes
版本说明�Q?br />�Q?�Q�对优势分数G的计��ؓG2.1版本�Q?br />�Q?�Q�启发函数还比较弱；
目前�׃��评机问题，暂时无法��试�Q�只有看晚上的练习赛了�?br />————————————————————————————————————————————————————
�?011�q?�?0日�?br />今天�U�然发现了Docx I的一个严重错误：在判定是否有炸弹的时候把true和false弄反了，�l�果��D��炸弹�Ҏ��无法使用�?br />现在�Ҏ��了之后（仍然命名为Docx I�Q�，TEST�l�果仍然不是很理惻I��只能虐别人的一些初�{�版本，高等版本�Q�比如那�?I Hate Zerg"的版�?�Q�根本木有办法�?br />目前正在改进启发函数�Q�争取在明天下午之前出Docx II�?br />————————————————————————————————————————————————————
�?011�q?�?日�?br />真惊险！最后时�ȝ��于找��C��问题所在，�q�且把Docx II�l�最后一步改�q�得到的版本命名为Docx III�Q�提交到排位赛�?br />最后结�?#8230;…�q�行�Q�第3�?#8230;…只是严重怀疑有强省故意放水……
大概明天正式分组��p��出来�?#8230;…
————————————————————————————————————————————————————
�?011�q?�?日�?br />分组�l�果已经出来�Q�安徽队的�Ş势还是比较有利的……

好了�Q�在8�?0日下午以前都不用再管团体�Ҏ��赛了……全力冲刺个�h竞赛……
————————————————————————————————————————————————————
�?011�q?�?0日�?br />团体�Ҏ��赛最后冲刺�?br />今天把几个地方的�p�L��改了一下，一些看��h��很傻的决�{�也得到了修正。不�q�晚上练习赛的结果仍然很不理�?#8230;…
��了�Q�明�?/4册��{�着被血�z�吧�?#8230;…

现在�q�有一�Ҏ��_��乱搞一下吧�?#8230;…
————————————————————————————————————————————————————
�?011�q?�?1日�?br />最�l�结果：八强�Q?/4册��中被湖南血�z?br />
昄��是一个预想之中的�l�果……�q�是应验了那句话�Q�团体对抗赛��到湖南��是找死……
�q�次�Q�本沙茶真的已经��力�?#8230;…
明年再来�?#8230;…

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

Mato_No1 — Wed, 20 Jul 2011 15:07:00 GMT
     摘要: 【原题见�q�里】很明显的精��覆盖的模型�Q?2个零�Ӟ��再加上它们经�q�旋转、翻转后的不同�Ş�Ӟ��?0�U�，每种又可以放在不同的位置�Q�只看最左上的那个珠子）一�U�零件的一�U�位�|�就是一行。列�Q�限�Ӟ��有两�U�：每个格子只能放一个（55列）�Q�以及每个零�Ӟ��注意是每个零�Ӟ��不是每种零�g�Q�只能用一�ơ（12列）�Q�共67列。预先放的那些零件可以看成预先选中的行。然后DLX�_��覆盖卛_��。下面是DLX�_��覆盖的几个易�늂��Q�（1�Q?..  阅读全文

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

NOI2008 party

Mato_No1 — Thu, 14 Jul 2011 04:23:00 GMT
原题�?a title="�q�里" >�q�里�Q�BZOJ和BSOJ都挂了，真杯��P��只能借助RQ了囧……�Q?br />
隑ֺ�不是很大�Q�就是特�D�情冉|��较多�Q�比较猥琐（不过本题数据弱，��q��不考虑所有的�Ҏ��情况也能�q?个点�Q��?br />首先O(NM)的朴素算法很好想刎ͼ�枚�DK�Q�然后给每个�l�点�~�号卛_��。在�~�号�Ӟ��先随便指定一个未�~�号的点�Q�设它的�~�号�?�Q�然后遍历所有和它相兌��的边�Q�这里可以把原图惌��成一个无向图�Q�，��这些边的另一个端点编上号卛_��Q�中间若某个点的�~�号出现矛盾�Q�则�q�个K不合法，否则�q�个K合法�?br />然后�q�行优化�Q�合法的K实际上是有限制的�Q�它必然是某个数的因敎ͼ�具体来说�Q�对�q�个图进行DFS�Q��ƈ考察其中所有的跨越边和逆向边，对于跨越�?lt;i, j>�Q�设遍历树中i、j间距��MؓD�Q�则合法的K必然�?D-1)的因敎ͼ�因�ؓi和遍历树中j的父�l�点都有指向j的边�Q�它们的�~�号应相同，而它们之间的距离�?D-1)�Q�；对于逆向�?lt;i, j>�Q�设遍历树中i、j间距��MؓD'�Q�则合法的K必然�?D'+1)的因敎ͼ�因�ؓ�q�里形成了一个环�Q�环的长度�ؓ(D'+1)�Q�。这样一来就明显�~�小了K的取��D��_��再进行枚举，��可以显著羃短时间�?br />
下面是一些极其猥琐的�Ҏ��情况�Q?br />�Q?�Q�根据题意，必须是K�c�L��c�都有，因此在尝试编��h��功（没有发生��M��矛盾�Q�后�Q�还要看一�?span style="color: red">实际出现的编��h��?/strong>是否�{�于K�Q�若��于K�Q�同样不合法�Q?br />�Q?�Q�该囄��基图可能不连通，此时对于其基囄��每个�q�通块�Q�其�~�号互不影响�Q�所以要�Ҏ��个连通块分别�l�计实际出现的编��h��目，讑֮�们的和�ؓSUM�Q�则不大于SUM的K值均合法�Q�只要中间不出现矛盾�Q�，因此可以直接得到最大��gؓSUM�Q�提前结束；不过�Q�这�U�特判只有在��d��实际出现的编��h��目小于K的情况下才能�q�行�Q?br />�Q?�Q�由于考察的是实际出现的编��h��目，因此最后求出的最大倹{��最��值可能小�?�Q�这时应作出如下处理�Q�若最大值小�?�Q�则无解�Q�若最��值小�?�Q�则��最��值改�?�?br />
本题比较猥琐的数据是�W?�?�?个点�Q�分别出��C��上述的第�Q?�Q�、（2�Q�、（3�Q�种�Ҏ��情况�Q�此外，�q�三个点建出的图中竟然没有一条跨��边或逆向边！

代码�Q?
#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 �l�护数列(sequence)】Splay Tree处理序列问题

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

【原题见�q�里�?br />本题是Splay Tree处理序列问题�Q�也��是当线�D�|��用）的一个典型例题�?br />
Splay Tree之所以可以当�U�段树用�Q�是因�ؓ它可以支持一个序列，然后�?#8220;左端前趋伸展到根�Q�右端后�l��展到根的叛_��l�点�Q�取根的叛_��l�点的左子结�?#8221;�q�种伸展�Ҏ��Q�对一个序列中的一整段�q�行整体操作。由于要防止出现前趋或后�l�不存在的情况，需要在�q�个序列的两端加入两个边界结点，要求其��g��能媄响到�l�点各种记蝲信息的维护（多取0�?#8734;�?∞�Q�。这两个边界�l�点在树中永�q�存在，不会被删除�?br />
�Q?�Q�结点的引用�Q?br />在当�U�段树用的Splay Tree中，真正的关键字是下标而不是��|��因此�Q?#8220;序列中第i个结�?#8221;实际上对应的�?#8220;树中�W?i+1)��的�l�点”�Q�因为左边还有一个边界结点）�Q�这��p��明在对结点引用时需要找�W�K��的操作。因此，下面�?#8220;�l�点x”指的�?#8220;树中�W?x+1)��的�l�点”�?br />�Q?�Q�标讎ͼ�
在线�D�|��中，如果对一个结�Ҏ��表示的线�D�|��体进行了某种操作�Q�需要在�q�个�l�点上打上一个标讎ͼ�在下一�ơ再扑ֈ��q�个�l�点�Ӟ��其标记就会下攑ֈ�其两个子�l�点上。在Splay Tree中也可以引入标记。比如要对[2, 6]�q�一�D�进行整体操作，��将�l�点1伸展到根的位�|�，��结�?伸展到根的右子树的位�|�，然后�l�点7的左子树��p��C�[2, 6]�q�一�D�，对这��子树的根结�Ҏ��上标记�ƈ立即生效�Q�必��L��立即生效�Q�而不是等下一�ơ引用再生效�Q�，也就是立��x��变该�l�点记录的一些信息的倹{��如果下�ơ再�ơ引用到�q�个�l�点�Q�就要将其标��C��攑ֈ�其两个子�l�点处；
需要注意的一�Ҏ��Q�如果要伸展某个�l�点x到r的子�l�点的位�|�，��必��M��证从x原来的位�|�到r的这个子�l�点�Q�x伸展后的位置�Q�上的所有结点上均没有标讎ͼ�否则��׃��D��标记混�ؕ。因此，必须首先扑ֈ��q�个�l�点x�Q�在此过�E�中不断下放标记�?br />�Q?�Q�自底向上维护的信息�Q?br />标记可以看成一�U�自��向下维护的信息。除了标��C��外，作�ؓ“�U�段�?#8221;�Q�往往�q�要�l�护一些自底向上维护的信息。比如在sequence�q�题中，��有lmax�Q�左�D�连�l�最大和�Q�、rmax�Q�右�D�连�l�最大和�Q�、midmax�Q�全�D�连�l�最大和�Q�以及sum�Q�全�D�|��d��Q�等信息要维护。对于这�c�M��东其实也很好办，因�ؓ子树大小�Q�sz域）��是一�U�自底向上维护的信息�Q�因此对于这些信息只要按照维护sz域的办法�l�护卛_��Q�统一写在upd函数里）。唯一的不同点是打标记时它们的值可能要改变�?br />�Q?�Q�对�q�箋插入的结点徏树：
本题的插入不是一个一个插入，而是一下子插入一整段�Q�因此需要先��它们徏成一��|��。一般徏树操作都是递归的，�q�里也一栗��设目前要对A[l..r]建树�Q�A为待插入序列�Q�，若l>r则退出，否则扑ֈ�位于中间的元素mid = l + r >> 1�Q�将A[mid]作根�Q�再对A[l..mid-1]建左子树�Q�对A[mid+1..r]建右子树卛_��。这样可以保证一开始徏的就是一��^衡树�Q�减��常数因子�?br />�Q?�Q�回收空��_��
�Ҏ��本题的数据范围提�C�，插入的结�Ҏ��L��最多可能达�?000000�Q�但在�Q何时��L��中最多只�?00002个结点（包括两个边界�Q�，此时��Z��节省�I�间�Q�可以采用��@环队列回收空间的�Ҏ��。即�Q�一开始将所有的可用�I�间�Q�可用下标，本题�?~500002�Q�存在��@环队列Q里，同时讄��头尾指针front和rear�Q�每�ơ如果有新结�Ҏ��入，��取出Q[front]�q�作为新�l�点的下标，如果有结点要删除�Q�本题是一�ơ删除整��子树，因此在删除后需要分别回收它们的�I�间�Q�，则从rear开始，��每个删除的�l�点的下标放回到Q里。当�Ӟ��q�种�Ҏ��是要牺牲一定的旉��的，因此在空间不是特别吃紧的情况下不要用�?br />
�?012�q?�?6日更新�?br />今天重写sequence的时候，�U�然发现加入的边界点可能会对lmax、rmax、midmax�{�的�l�护造成影响�Q�当序列中所有的值都是负数时�Q�若边界点的��D��?�Q�将使这3个��g��?�Q�所以，边界点的值应设�ؓ-INF�Q�不会媄响到sum�Q�因为可以单独调出[l, r]的sum�Q�避开边界�Q�。这��p��明�ƈ非所有这��L��题中都可以设�|�边界点�Q�比如HFTSC2011的那题就不行�Q�，如果边界点会对维护的信息造成影响�Q�就不能讄��边界点，在各个操作中�Q�分4�U�情况判断。（代码已经修改�Q?br />
下面上代码了�Q?
#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;
}

最后把我的�q�个代码与BYVoid��犇的本题代码进行测试比较，�l�果�Q�BYVoid��犇的代码见�q�里�Q�：

BYVoid��犇的：

本沙茶的�Q?br />

【相兌��文�?br />Mato_No1 2011-06-21 16:06 发表评论

Mato_No1 — Sat, 18 Jun 2011 13:21:00 GMT
     摘要: 今天真是有纪忉|��义啊……以前试着捉了N遍的cashier今天竟然AC了，本沙茶终于掌握了�q��树！�Q�！【Splay Tree及其实现�?lt;1>�l�点记录的信息：一般情况下Splay Tree是用�U�性存储器�Q�结构数�l�）来存储的�Q�可以避免在Linux下的指针异常问题。这样对于某个结点，臛_��要记录以下的域：��|��又叫关键字）、左子结点的下标、右子结点的下标、父�l�点下标、子树大...  阅读全文

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