欧美成人精品在线,亚洲欧美日韩成人,国产精品久久久久久久久免费樱桃

【AHOI2013复仇】二�l�DP优化的几道题�ȝ��

Mato_No1 — Sun, 03 Mar 2013 07:25:00 GMT

�?�?a title="BZOJ1713" >BZOJ1713
F[i][j]=max{F[i1][j1] - (sA[i-1]-sA[i1])² - (sB[j-1]-sB[j1])²} + A[i]*B[j], 0<=i1对这个式子进行化��Q?br />F[i][j]=max{F[i1][j1] - sA[i1]² + 2*sA[i-1]*sA[i1] - sB[j1]² + 2*sB[j-1]*sB[j1]}+A[i]*B[j]-sA[i-1]²-sB[j-1]²
对于一�l�的情况�Q�很�Ҏ��处理——中间��是一条直�U�，然而这是二�l�的�Q�对于这�U?D/2D的DP方程�Q�要优化到O(N²)�U�别�Q�需要两步�?br />注意到决�{�式中除了F[i1][j1]外，其它部分都要么只与i1有关�Q�要么只与j1有关。因此，可以把阶�D�i的各个状态作��Z��个整体，在之前得出的各个F[i][j]中，对于相同的j�Q�找到对于目前的i�Q�最优的那个决策——注意�Q�对于相同的j1�Q�里面所有与j1有关的东襉K��可以先不考虑了，只考虑(F[i1][j1] - sA[i1]² + 2*sA[i-1]*sA[i1])对于目前i的最优决�{�。这一步可以在�q�些直线形成的上凸壳中找刎ͼ�且满��_��{�单调性，可以用一个栈处理�Q�斜率优化）。然后，��这些最优决�{�以j��变量再组成一些直�U�，用栈�l�护它们的上凸壳�Q�对于每个j�Q�找到最优值即可�?br />注意事项�Q�在栈中删除直线的时候，如果之前的最优决�{�是�q�个被删掉的直线�Q�则要将最优决�{�先�|��ؓ不存在，然后再插入新直线后设为新直线。另外，要特别注意��^行的情况�?br />
�?】LCIS
�l�典问题�Q�利用上面的分步优化思想�Q�很�Ҏ��用线�D�|��得到一个O(N²logN)的做法�?br />
�?�?a title="[SCOI2010]股票交易 " >[SCOI2010]股票交易
F[i][j]=max{F[i-1][j], max{F[i-W-1][j-a]-A*a, F[i-W-1][j+b]+b*B}}, j<=maxP, 1<=a<=maxA, 1<=b<=maxB
注意对于相同的j�Q�计��方法是一��L��Q�且是一条直�U�（�׃��有范围所以其实是�U�段�Q��?br />所以，计算阶段i�Ӟ��可以��?i-W-1)阶段所有的决策当成�U�段插入�Q�这些线�D늚�斜率都相�{�，因此比较好维护，只需要判断边界即可�?br />
注意�Q�NOI2011的show虽然也符合对于相同的j计算�Ҏ��一��P��但它��׃��能优化，因�ؓ它的决策是不�q�箋且无规律的，没有��M��几何性质。因此，它只能用O(N³)的算法计��出所有状态�?br />

Mato_No1 2013-03-03 15:25 发表评论

Mato_No1 — Thu, 28 Feb 2013 10:29:00 GMT

摘要: 原题地址写了几天�l�于写出来了……�Q�显�Ӟ��我太�׃��Q�请各位��犇不要鄙视�Q�在有加点的情况下，动态地�l�护凸包�Q�有以下两种�Ҏ��Q?lt;1>�l�护上、下凸壳�Q�本沙茶采用的方法）�Q�凸包可以拆成上、下凸壳�Q�对它们分别�l�护。两个凸壛_��按照下面定义�?lt;关系�Q�即先x增、再y增）排序�Q�注意，两个凸壳的两端是相同的，均�ؓ整个凸包的最��点与最大点�Q�除两端外，它们没有公共定点。以上凸壳�ؓ�?.. 阅读全文

Mato_No1 2013-02-28 18:29 发表评论

Mato_No1 — Wed, 06 Feb 2013 15:26:00 GMT

RT�Q?br />今天又优化了一下JZPKIL�Q�用上了各种无�ȝ��手段�Q�仍然无法干掉后两个点，�q�且BZOJ上的��L��?0s也无法实玎ͼ�后两个点一个就�?0s�Q�，
看来��Z��l�合数的做法�׃��要枚丑֛�敎ͼ��实不行……
�Q�注�Q�后两个�Ҏ��人工构造的猥琐数据�Q�所有的N都是若干个小质数之积�Q�因��C��数都上千�Q�有的甚至上�?#8230;…�Q?br />
认输�?#8230;…
Orz @sevenk

Mato_No1 2013-02-06 23:26 发表评论

【AHOI2013复仇】s-t�W�K短简单�\问题

Mato_No1 — Sun, 23 Sep 2012 06:28:00 GMT

[SCOI2007 kshort]
求图的s-t�W�K短简单�\问题�Q�若有长度相同的�Q�字典序��的优先�?br />
首先�Q�由于是��单�\�Q�所�?a title="A*" href="http://www.shnenglu.com/MatoNo1/archive/2011/05/01/145456.html">A*是不能做的，因�ؓ有可能有两条s-i�Q�i为某个中间点�Q��\P1和P2�Q�P1比P2短，但由于P1到达的顶点与P2不同�Q�导致最�l�沿P1到达t的�\径长度长于沿P2到达t的（甚至有可能沿P1�Ҏ��C��了t�Q�。然后，如果直接用DFS�Q�由于要求的是第K优解�Q�而不是最优解�Q�所以不能��用最优性剪枝（包括分支限界�Q�，因此专门为最优性剪枝服务的“改变搜烦��序”技巧也不能使用了，因此�Q�能够��用的只有可行性剪枝，而本题的数据范围使得�q�种��法必然TLE�?br />
正解是一�U�由�q�代加深思想扩展得到�?#8220;�q�代变优”DFS。设�|�一个�\径长度上限Z�Q�搜索s到t的所有简单�\�Q�在搜烦�q�程中，遇到长度大于Z的�\径就停止�Q�剪枝）�Q�然后，若得到�\径不��K条，则增加Z的��|��重新开始搜索，直到得到的�\径��L��大于�{�于K条�ؓ止。这里可以进行启发式的优化，设g[i]为点i到t的最短�\长度�Q�则搜烦�q�程中，假设目前搜到点i�Q�则�Q�目前�\径长�?g[i]�Q�是�Ҏ��条�\径最短长度的乐观估计�Q�如果这个��D��q�了Z�Q�就可以剪枝�Q�但在剪枝之前要��C��q�个��过了Z的启发��|��取其中最��的作�ؓ下一�ơ�P代的Z倹{��那么对于字典序肿么办？可以在搜索过�E�中�Q�强制先搜编号小的结点，�q�样得到的s-t路径必然是字典序递增的。另外只要求出第K条�\径，搜烦��可以终止，因�ؓ�Ҏ��证明�Q�题目要求的�W�K短的路径一定已�l�求出来了（只不�q�不一定是最后一条而已�Q�，扑ֈ�卛_��。此外，在搜索过�E�中不要忘了可行性剪枝，��是如果沿目前搜到的路径已经��C��了t了，剪枝�?br />
“�q�代变优”DFS�Q�就是设�|�一个解的评价值的上限�Q�最��|��或下限（最大��|��Q�在搜烦�q�程中，如果实际评�h��|��或者启发��|��如果可以加启发式优化的话�Q�越�q�这个限�Ӟ��则剪枝。在一�ơ搜索后�Q�如果没有得到符合要求的解，��将该限制�?span style="color: red">设�ؓ本次搜烦�q�程中越�?#8220;��?#8221;得最�q�的那个�?/strong>�Q�重新开始搜索，直到扑ֈ�所需要的解或�?span style="color: red">发现无解�Q�如果一�ơ搜索中没有发生��界�Q�却仍然没有扑ֈ�解）为止。其应用主要体现在两个方面：�Q?�Q�搜索树�q�深甚至无限深，但所需求的那个解却不深的情况；�Q?�Q�求�W�K优解的情��c�?br />
代码�Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
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--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
    int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
    int a, b, w;
    bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
    re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
    E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
    E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
    int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
    re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
    sort(_E, _E + m0);
    re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
    re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
    int x, y, d0, d1;
    for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
        x = Q[front]; d0 = dist[x];
        for (int p=E0[x].next; p != x; p=E0[p].next) {
            y = E0[p].b; d1 = d0 + E0[p].w;
            if (d1 < dist[y]) {
                dist[y] = d1;
                if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
            }
        }
        vst[x] = 0;
    }
}
void dfs(int x, int sum)
{
    if (x == t) {
        if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
        else if (sum < Z0) Z0 = sum;
        return;
    } else {
        int h0 = sum + dist[x];
        if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
        vst0[x] = ++_FL; Q[0] = x; int _x, _y;
        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;
                if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
            }
        }
        if (vst0[t] != _FL) return;
        for (int p=E[x].next; p != x; p=E[p].next) {
            _y = E[p].b;
            if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
        }
    }
}
void solve()
{
    Z = dist[s]; int No0 = 0; _FL = 0;
    while (1) {
        Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
        vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
        if (res_ex) {
            No0 = K - No0;
            re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
            break;
        } else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
    }
}
void pri()
{
    if (res_ex) {
        printf("%d", res[0] + 1);
        re2(i, 1, reslen) printf("-%d", res[i] + 1);
        puts("");
    } else puts("No");
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-23 14:28 发表评论

【AHOI2013复仇】两道LIS模型题�ȝ��

Mato_No1 — Sat, 08 Sep 2012 12:40:00 GMT
最�q�做了两道LIS模型题，感觉到模型比较好�Q��ȝ��一下囧�?br />�?�?a title="[HAOI2007]上升序列 " >[HAOI2007]上升序列
预处理：设F[i]��Z��i开头的最长上升序列的长度�Q�怎么求不用说了吧�?#8230;…
假设目前需要求长度为M的、标号字典序最��的上升序列�Q�显然其�W�一个元素A[i]必须满��F[i]>=M�Q�注意，不是�{�于�Q�是大于�{�于�Q�）�Q�找到满��个条件的最��的i卛_��。然后，讄��前已�l�求��Z��该序列的�W�x个元素�ؓA[y]�Q�则�W?x+1)个元素A[z]需要满��的条�g是A[z]>A[y]�Q�且F[z]=F[y]-1�Q�找到满��个条件的最��的z即�ؓ该序列的�W?x+1)个元素。按照这�U�方法，扫描一遍就可以求出整个序列�Q�时间复杂度为O(N)。如果整个序列的最长上升序列长�?lt;M�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 = 10010,    MAXM = 1010, INF = ~0U >> 2;
int n, m, len, A[MAXN], F[MAXN], D[MAXN], res[MAXM];
void prepare()
{
    D[len = 0] = INF; int l, r, mid;
    rre(i, n) if (A[i] < D[len]) D[F[i] = ++len] = A[i]; else {
        l = 0; r = len;
        while (l < r) {
            mid = l + r + 1 >> 1;
            if (A[i] < D[mid]) l = mid; else r = mid - 1;
        }
        F[i] = l + 1; D[l + 1] = A[i];
    }
}
void solve()
{
    int x, y;
    re(i, n) if (F[i] >= m) {
        res[0] = A[i]; if (m == 1) return; x = m - 1; y = 1;
        re2(j, i+1, n) if (F[j] >= x && A[j] > res[y - 1]) {res[y++] = A[j]; if (y == m) return; else x--;}
    }
}
int main()
{
    scanf("%d", &n); re(i, n) scanf("%d", &A[i]);
    prepare();
    int m_s; scanf("%d", &m_s);
    re(i, m_s) {scanf("%d", &m); if (m > len) puts("Impossible"); else {solve(); re(j, m-1) printf("%d ", res[j]); printf("%d\n", res[m - 1]);}}
    return 0;
}

�?�?a title="[HAOI2006]数字序列 " >[HAOI2006]数字序列
首先�Q�由于序列的所有元素都是整敎ͼ�所以可以将原序列的所有元素减��d��的下标，�q�样��把上升序列转化��Z��下降序列了�?br />�W�一问的�l�果昄��是(N-新序列的最长不下降序列长度)。关键在于第二问。以下A均表�C�新序列�?br />设F[i]��Z��A[i]�l�尾的最长不下降序列长度�Q�同��P��求法不用说了�Q�，G[i]为在A[i]不修改的前提下将A[0..i]转变��Z��下降序列的最��修攚w��。首先求出F[i]�Q�然后在求G[i]�Ӟ��枚�D上一�?#8220;不动�?#8221;�Q�就是不修改的元素）A[j]�Q�显然必��L��A[j]<=A[i]且F[j]=F[i]-1�Q�，�q�样最��修攚w��是G[j]+(��A[j..i]转变��Z��下降序列的最��修攚w��Q�。可以证明，A[j..i]的最优修�Ҏ��案必然是��A[j+1..t]全部修改为A[j]�Q�A[t+1..i]全部修改为A[i]�Q�这里t是一个[j..i]范围的倹{��问题就是如何求出最优的t�Q?br />一开始，假设t=j�Q�即把A[j+1..i-1]全部修改为A[i]�Q�计��出修改量，设�ؓS。然后，�׃��A[j+1..i-1]之间的元素要么小于A[j]�Q�要么大于A[i]�Q�这个是昄��的囧�Q�，我们把小于A[j]的元素称�?#8220;��数”�Q�把大于A[i]的元素称�?#8220;大数”�Q�则当t取t0�Ӟ��修改量�ؓS-(A[i]-A[j])*(A[j+1..t0]中的“��数”个数减去“大数”个数�Q�。这��P��只需扫描一下，求出使得(A[j+1..t0]中的“��数”个数减去“大数”个数�Q�值最大的t0卛_��?br />当然�q�有一个问题，对于同一个i�Q�满��?#8220;A[j]<=A[i]且F[j]=F[i]-1”的元素个数可能有很多�Q�如果一个一个枚举，一个一个扫描，会很慢的�?#8230;…解决�Ҏ��是，求出满��q�个条�g的j中最��的一个，设�ؓj0�Q�然后把A[j0+1..i-1]中的所�?#8220;��数”�?#8220;大数”全部处理出来�Q�然后用�c�M��前缀和的�Ҏ��p��搞了�?#8230;…当然�Q��ؓ了找到j0�Q�需要徏一个二分图�Q�边�?F[i], i)�?br />最后，��Z��方便�Q�可以把A序列的左边加一�?INF�Q�右边加一�?INF。最后�ȝ��旉��复杂度，理论上�ؓO(N²)�Q�但�׃��是随机数据，所以远�q�达不到�q�个�U�别�?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 = 40010, INF = ~0U >> 2;
struct edge {
    int a, b, pre, next;
} E[MAXN << 1];
int n, m, A[MAXN], D[MAXN], F[MAXN], W[MAXN], res1;
ll G[MAXN], res2;
void init_d()
{
    re(i, n) E[i].pre = E[i].next = i; m = n;
}
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()
{
    scanf("%d", &n);
    A[0] = -INF; re1(i, n) {scanf("%d", &A[i]); A[i] -= i;} A[++n] = INF; n++;
}
void solve()
{
    init_d(); F[0] = 0; G[0] = 0; D[0] = -INF; add_edge(0, 0); int len = 0, l, r, mid, x, maxw; ll sum, tmp;
    re2(i, 1, n) {
        if (A[i] >= D[len]) D[F[i] = ++len] = A[i]; else {
            l = 0; r = len;
            while (l < r) {
                mid = l + r + 1 >> 1;
                if (A[i] >= D[mid]) l = mid; else r = mid - 1;
            }
            D[F[i] = ++l] = A[i];
        }
        for (int p=E[F[i]-1].next; ; p=E[p].next) if (A[i] >= A[x = E[p].b]) break;
        W[x] = 0; re2(j, x+1, i) if (A[j] < A[i]) W[j] = W[j - 1] + 1; else W[j] = W[j - 1] - 1;
        sum = 0; maxw = -INF; G[i] = ~0Ull >> 2;
        rre2(j, i, x) {
            if (A[j] <= A[i] && F[j] == F[i] - 1) {
                tmp = G[j] + sum; if (tmp < G[i]) G[i] = tmp;
                tmp = G[j] + sum - (ll) (maxw - W[j]) * (A[i] - A[j]); if (tmp < G[i]) G[i] = tmp;
            }
            if (A[j] > A[i]) sum += A[j] - A[i]; else sum += A[i] - A[j];
            if (W[j] > maxw) maxw = W[j];
        }
        add_edge(F[i], i);
    }
    res1 = n - F[n - 1] - 1; res2 = G[n - 1];
}
void pri()
{
    cout << res1 << endl << res2 << endl;
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-08 20:40 发表评论

【AHOI2013复仇】ZJOI2008 骑士题解

Mato_No1 — Sat, 01 Sep 2012 09:03:00 GMT

原题地址
本沙茶的�W�一个无向环套树模型�Q�纪念一�?#8230;…

环套树，指的是每个连通块中点数都�{�于�Ҏ��的无向图�Q�称为无向环套树�Q�或者是每个�Ҏ��且只有一个前��（�U�Cؓ内向环套树）或后�l�（�U�Cؓ外向环套树）的有向图�Q�由于这个图的每个连通块当中有且只有一个环�Q�注意，可能是自环，即长度�ؓ1的环�Q�，且这个环上的每个炚w��可以当作根引��Z��|��Q�所以叫“环套�?#8221;�?br />
对于无向环套树，先将整个图进行一�ơDFS�Q�当中如果发现有逆向边（�q�条边第一�ơ被发现必然是作为逆向边的�Q�也��是��L��是终点的后代�Q�，��p��明找��C��q�个环，记录其�v点和�l�点�Q�注意，如果有多个连通块的话�Q�不能退出，要��l�遍历完�Q�，再不断上溯（因此在DFS�q�程中当然要记录父边了囧�Q�，��可以找到整个环了，然后再以环上的结点�ؓ根徏树即可，�q�样依次处理每个�q�通块�?br />
对于内向环套树（外向�c�M��Q�，扄��更�ؓ��单，只需要�Q选一个点�Q�不断去扑֮�的前��，同时记录扑ֈ�的点序列�Q�直到某个点在序列中出现两次为止�Q�此时这个点以及序列中它两次出现的位�|�中间的所有点�Q�就是环上的点，��序也顺便记录下来，然后树也不用��Z��Q�直接在原图中找��p��了�?br />
对于�q�题�Q�由于每个点都有且只有一个后�l�，所以是外向环套树，不过本沙茶更們֐�于它的基图（无向图，是无向环套树�Q�，然后��是一个DP了囧……

代码�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 = 1000010;
const ll INF = ~0Ull >> 2;
struct edge {
    int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, A[MAXN], stk[MAXN], st[MAXN], pr[MAXN], Q[MAXN];
ll F[MAXN][2], res = 0;
bool vst[MAXN], vst0[MAXN];
void init_d()
{
    re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; if (n & 1) m0 = n + 1; else m0 = n; 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()
{
    scanf("%d", &n); int x; init_d();
    re(i, n) {
        scanf("%d%d", &A[i], &x); add_edge0(--x, i);
    }
}
void sol0(int x)
{
    Q[0] = x; int i, j, front, rear;
    for (front=0, rear=0; front<=rear; front++) {
        i = Q[front];
        for (int p=E0[i].next; p != i; p=E0[p].next) {
            j = E0[p].b;
            if (!vst0[j]) {Q[++rear] = j; vst0[j] = 1; add_edge(i, j);}
        }
    }
    rre3(z, rear, 0) {
        i = Q[z];
        F[i][0] = 0; F[i][1] = A[i];
        for (int p=E[i].next; p != i; p=E[p].next) {
            j = E[p].b; F[i][0] += F[j][0] >= F[j][1] ? F[j][0] : F[j][1]; F[i][1] += F[j][0];
        }
    }
}
void solve()
{
    re(i, n) {vst[i] = vst0[i] = 0; st[i] = E0[i].next;} int x, y, tp, x0, y0; bool FF, FF2; ll tmp0, tmp1, tmp00, tmp01, res0;
    re(i, n) if (!vst[i]) {
        stk[tp = 0] = i; vst[i] = 1; FF2 = 0;
        while (tp >= 0) {
            x = stk[tp]; FF = 0;
            for (int p=st[x]; p != x; p=E0[p].next) {
                y = E0[p].b;
                if (!vst[y]) {vst[y] = 1; stk[++tp] = y; pr[y] = p; st[x] = E0[p].next; FF = 1; break;}
                else if (p != (pr[x] ^ 1) && !FF2) {FF2 = 1; x0 = x; y0 = y;}
            }
            if (!FF) tp--;
        }
        if (FF2) {
            tp = 0; vst0[y0] = 1; while (x0 != y0) {stk[tp++] = x0; vst0[x0] = 1; x0 = E0[pr[x0]].a;} stk[tp++] = y0;
            re(j, tp) sol0(stk[j]);
            tmp0 = F[stk[0]][0]; tmp1 = -INF;
            re2(j, 1, tp) {
                tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
                tmp01 = tmp0 + F[stk[j]][1];
                tmp0 = tmp00; tmp1 = tmp01;
            }
            res0 = tmp0 >= tmp1 ? tmp0 : tmp1;
            tmp0 = -INF; tmp1 = F[stk[0]][1];
            re2(j, 1, tp) {
                tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
                tmp01 = tmp0 + F[stk[j]][1];
                tmp0 = tmp00; tmp1 = tmp01;
            }
            res += res0 >= tmp0 ? res0 : tmp0;
        }
    }
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-01 17:03 发表评论

XOR专题�Q�一�Q�：异或方程�l�的解法

Mato_No1 — Sun, 20 May 2012 02:17:00 GMT
     摘要: 【异或（XOR�Q�运��由于与“奇偶�?#8221;密切相关�Q�经常出现在有关奇偶性和二进制的题目中】很多异或问题都要涉及到解异或方�E�组�Q�因此首先要搞懂异或方程�l�的解法。（1�Q�异或方�E�组的格式（设有n个未知数�Q�m个方�E�）�Q�a11*x1 XOR a12*x2 XOR ... XOR a1n*xn = b1a21*x1 XOR a22*x2 XOR ... XOR a2n*xn = b2R...  阅读全文

Mato_No1 2012-05-20 10:17 发表评论

炮兵阵地以及与其相关的一�cȝ��压DP问题

Mato_No1 — Sat, 10 Mar 2012 15:27:00 GMT

原题地址
说实话我�W�一�ơ尝试写炮兵阵地是在2009�q?#8230;…已经�q�去两年多了�Q�终于找��C��一个好的解�?#8230;…庆祝一�?#8230;…

【状态压�~�DP�?br />所谓状态压�~�DP�Q�就是对于某些DP问题�Q�每一阶段的状态都有很多维�Q�要利用某些手段��它们压�~�到一�l�_��一个正整数�Q�，��Z��q�行状态的�_��Q�去掉不合法的状态）�Q�然后再�q�行DP。这里讲的主要是传统的状压DP�Q�有一�U�基�?#8220;插头”的DP�Q�更高��Q�以后再搞�?br />对于本题�Q�可以设计出一个这��L��状态：[0..1][0..1][0..1]...[0..1]�Q�有M个[0..1]�Q�，表示该行的每个格子放不放炮兵�Q�如果放�Q��ؓ1�Q�否则�ؓ0。显�Ӟ��q�是一个M位二�q�制敎ͼ�如果能把它们压羃成一个int��好了�?br />
【如何压�~��?br />�W�一个问题是�q�么多维的状态如何压�~�的问题�?br />对于本题�Q�由于是二进制数�Q�直接压�~�就可以了。但是对于某些情况，状态是个三�q�制敎ͼ�每个格子的属性都�?�U�）甚至更多�q�制敎ͼ��q�样�Q�直接压�~�会��D��无法使用位运��，从而��“解压”变得很麻烦，耗时也很长（需要暴力）�Q�因此，可以��每位三�q�制都拆成两位二�q�制�Q?br />0->00
1->01
2->10
�Q�当�?拆成10�?拆成11也木有问题，只要能区分开��p��了）
�q�样�Q�每个状态就可以�?个二�q�制数来表示�Q�可以在构造出所有合法状态以后将每个状态所对应的两位二�q�制数存到struct里面�Q��用时调出卛_��?br />
【如何精��?br />�q�个问题是最重要的，因�ؓ�Q�如果不�_��Q�在枚�D状态以及�{�Uȝ��时候就会枚丑ֈ�很多不合法状态，��D��旉��费�?br />所谓精��Q�是指在预处理以及DP�q�程中，��量避开不合法状态�?br />�Q?�Q�预处理中的�_��Q?br />包括3个部分：
<1>扑ֈ�所有可能的合法状态�ƈ�~�号�Q�根据题意限�Ӟ��有的状态在阶段内就不合法（比如本题�Q�一行一阶段�Q�那么凡是有两个1位的距离��于2的状态都不合法）�Q�而且�q�种状态所占的比重往往�q�很大（本题中，M=10�Ӟ��也只�?0�U�可能的合法状态）�Q�此�Ӟ��Z��扑ֈ��q�些合法状态，可以DFS构造实现�?br />需要注意的是，有的题不光要扑ֈ�一个阶�D�内的合法状态，�q�要扑ֈ�两个或两个以上阶�D�内的合法状态（比如那个有关多米诺骨牌的题）�Q�此旉��要两个int同时DFS�Q?br />在找到合法状态以后，需要对每个合法状态进行编��P��以达�?#8220;压羃”的目的。这里就涉及��C��状态编号和状态表�C�的问题�Q�比如，状�?001�Q�表�C�Zؓ9�Q�在DFS中第一个被搜到�Q�因此编号�ؓ0�Q�不要搞混了�q�两个（��其不要搞�؜“�~�号�?”�?#8220;状态表�C�Zؓ0”�Q�它们是不同的）。在预处理和DP的过�E�中�Q�所有涉及到状态的数组下标�Q�全部是�~�号而不是表�C�，知道�~�号要求表示�Q�可以在DFS中记录的数组里面调，而知道表�C��求编��P��可以利用逆数�l�或者哈希；
<2>扑ֈ�每一阶段的合法状态：即��?lt;1>中被判定为合法的状态，在具体的各个阶段中也未必合法�Q�比如本题，如果某一行的某一个位�|�是'H'�Q�不能放�Q�而某一个状态在�q�里放了�Q�则不合法）�Q�因此要�Ҏ��个阶�D�再枚�D一遍，扑ֈ�真正合法的状态，�q�计入一个vector�Q?br /><3>扑ֈ�状态�{�U�M��的合法状态：在状态�{�U�M��Q�往往要求状态不冲突�Q�比如本题，在连�l�的三个阶段中，都不能有某一位有两个�?的情况）�Q�因此，�q�要枚�D每个状态在转移时与其不冲突的状态，�q�计入vector�?br />注意�Q�有时候这一步不是很�Ҏ��q�行�Q�需要在DP�q�程中进行；
�Q?�Q�DP�q�程中的�_��Q?br />DP�q�程中，枚�D状态、�{�U�d��{�都只枚丑֐�法的�Q�在vector里面调（注意vector里记录的全都是状态编可��不是表�C�！�Q�，可以大大减少枚�D量，不过有时候，�q�会有一些时间浪费，�q�时候，可以采取一些其它的办法来精��Q�比如再�ơ进行DFS构造合法状态等�?br />
��M��Q�这�c�问题的目标��是“�_��Q�精��Q�再�_��Q��枚�D到的不合法状态减到最��?#8221;�?br />
代码�Q?br />
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
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 pb push_back
#define IR iterator
typedef vector <int> vi;
const int MAXN = 103, MAXM = 11, MAXS = 100, INF = ~0U >> 2;
int n, m, S, A[MAXN], B[MAXS], T1[MAXS], F[MAXN][MAXS][MAXS], res;
bool F0[MAXN][MAXS];
vi P0[MAXN], P1[MAXS][MAXS];
void init()
{
     scanf("%d%d", &n, &m); getchar();
     re1(i, n) {A[i] = 0; re(j, m) A[i] |= ((getchar() == 'P') << j); getchar();}
}
void dfs(int v, int ST)
{
    if (v >= m) B[S++] = ST; else {dfs(v + 3, ST | (1 << v)); dfs(v + 1, ST);}
}
void prepare()
{
    S = 0; dfs(0, 0);
    re(i, S) {T1[i] = 0; for (int j=B[i]; j; j-=j&(-j)) T1[i]++;}
    re1(i, n) re(j, S) if (!(~A[i] & B[j])) {P0[i].pb(j); F0[i][j] = 1;} P0[0].pb(S - 1); F0[0][S - 1] = 1;
    re(i, S) re(j, S) if (!(B[i] & B[j])) re(k, S) if (!(B[i] & B[k]) && !(B[j] & B[k])) P1[i][j].pb(k);
}
void solve()
{
    re3(i, 0, n) re(j1, S) re(j2, S) F[i][j1][j2] = -INF; F[0][S - 1][S - 1] = 0;
    vi::IR vi_e0, vi_e1, vi_e2; int j0, j1, k, V;
    re(i, n) {
        vi_e0 = P0[i].end(); if (i) vi_e1 = P0[i - 1].end(); else vi_e1 = P0[i].end();
        for (vi::IR p=P0[i].begin(); p != vi_e0; p++)
            for (vi::IR p_=P0[i ? i - 1 : i].begin(); p_ != vi_e1; p_++) {
                j0 = *p; j1 = *p_;
                if (!(B[j0] & B[j1])) {
                    vi_e2 = P1[j0][j1].end();
                    for (vi::IR p__ = P1[j0][j1].begin(); p__ != vi_e2; p__++) {
                        k = *p__;
                        if (F0[i + 1][k]) {
                            V = F[i][j0][j1] + T1[k];
                            if (V > F[i + 1][k][j0]) F[i + 1][k][j0] = V;
                        }
                    }
                }
            }
    }
    res = 0; re(i, S) re(j, S) if (F[n][i][j] > res) res = F[n][i][j];
}
void pri()
{
     printf("%d\n", res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-03-10 23:27 发表评论

�U�段树操作极品题——HDU2871

Mato_No1 — Sun, 18 Dec 2011 00:58:00 GMT

原题地址
�q�是一道线�D�|��操作的极品题�Q�因为它�?个操作刚好覆盖了�U�段树操作问题的3�U�处理思�\�Q�可以说是把�U�段树操作的全部内容都包含进��M��?br />
�U�段树是一�U�静态的数据�l�构�Q�因��Z��늺��D�|��一旦徏成，其�Ş态就永远不会发生变化�Q�改变的仅仅是结点上记录的各�U�信息的倹{��因此，对于�U�段树操作，核心问题也就是如何维护和处理�q�些信息。�ȝ��来说�Q�对于线�D�|��l�点信息的维护和处理�Q�有以下3�U�基本思�\�Q?br />�Q?�Q�左叛_��中型�Q?br />所谓左叛_��中，��是用左叛_��l�点存储的信息来得到父结点存储的信息的��|��q�是最常见的线�D�|��l�护�Ҏ��。�D一些简单的例子�Q�比如结点的SUM域表�C��l�点区间上所有元素的和，那么�q�个域维护的�Ҏ��是“父结点SUM=左子�l�点SUM+叛_��l�点SUM”�Q�再比如�l�点的MAX/MIN域表�C��l�点区间上所有元素的最�?��|��那么�l�护�Ҏ��是“父结点MAX/MIN=max/min{左子�l�点MAX/MIN,叛_��l�点MAX/MIN}”。这�U�维护方法也比较��单，只要在每�ơ对子结点进行修改之后upd一下就行了�Q�对于那些自��向下递归�Q�而且涉及到改值的操作�Q�在递归完左叛_��l�点后一定要记得upd一下）�Q�在�q�之中有一个很重要的思想��是“左右�q�箋�D?#8221;思想�Q�如果题目中要求��L��一个区间内的具有某�U�性质的最长的�q�箋序列�Q�也��是子区��_��Q�比如最长连�l�上升子序列�?1值问题中�q�箋�?�D�|��者非0�D�（在具体问题中��是�q�箋的空闲段或者占用段�Q�等�Q�可以在每个�l�点上维护三个域�Q�lS、rS和S�Q�分别表�C��l�点区间左端�Q�从区间的最左端开始的�Q�具有这�U�性质的最长连�l�序列的长度�Q�该�l�点区间右端�Q�到区间的最右端�l�束的）��h��q�种性质的最长连�l�序列的长度和该区间内具有这�U�性质的最长连�l�序列的长度�Q�也��是要求的那个东东）�Q�则�l�护�Ҏ��?#8220;父结点lS=左子�l�点lS�Q�左子结点lS<左子�l�点len�Q�或左子�l�点len+叛_��l�点lS�Q�左子结点lS=左子�l�点len�Q�，父结点rS�c�M��Q�父�l�点S=max{左子�l�点S,叛_��l�点S,左子�l�点rS+叛_��l�点lS}”�Q�此外，�׃��要求的这个区间可能被拆成多个�q�箋的结点区��_��因此需要按��序合�ƈ�q�些区间�Q�合�q�的�Ҏ��是：讄��S0和S1�Q�S0表示不保证能延��下去的区间长度，S0=上一个区间的S1+本区间的lS�Q�S1表示可以延��下去的区间长度，S1=上一个区间的S1+本区间len�Q�如果本区间整个都是满��条�g的，即S=len�Q�或本区间的rS�Q�本区间不都是满��x��件的�Q�即S在HDU2871中，应用左右归中的方法维护的信息��是“最长连�l�空闲段”的长度，New操作需要；

�Q?�Q�调整边界型�Q?br />考虑�q�样一个问题：现在要插入、删除一些[0, 100000)的整敎ͼ��q�且在此�q�程中不断询问第K��的整数是多��，怎么办？�q��树可以实玎ͼ�但线�D�|��昄��是更好的�Ҏ��。对每个�l�点�Q�存储一个K0��D��C�Z��于该�l�点区间内的整数的个敎ͼ�则查扄��K��的时候只需要不断执行以下操作：Kth(A, K)�Q�表�C�在�l�点A代表的区间内扄��K��的�Q�然后，若K<=�l�点A的左子结点K0��|��则执行Kth(A的左子结�? K)�Q�否则执行Kth(A的右子结�? K-A左子�l�点的K0)�Q�这和��^衡树��似�Q�，直到扑ֈ�叶结点�ؓ止。这�U�方法称�?#8220;调整边界�?#8221;�Q�即随着�l�点深入�Q�不断羃��（自顶向下�Q�或扩大�Q�自底向上）范围�Q�最后找到结果。像扄��K��这��L��操作属于自顶向下型，而像“扑ֈ�X所在的��h��某种性质的最长的�q�箋区间”��属于自底向上型�Q�注意和本题的Free不一��P��Q?br />
�Q?�Q�标记辅助型�Q?br />�q�种�l�护信息的方法，特点是利用标记来�l�护信息�Q�即对于某些�l�点�Q�主要是叶结点，因�ؓ其标��C��再下放）�Q�直接��用标记来得到一些数据，比如对于HDU2871�q�一题，其中对于叶结点位于的插入�U�段的标��P��使用的就是标记�?br />
下面是本�?个操作的具体实现�Q?br /><1>�U�段树结点定义：
本题需要两��늺��D�|��Q�这是因为New与Free操作对于tot域（插入�U�段左端点的��M��敎ͼ�会造成不同的媄响，具体来说�Q�在New操作中，tot��g��会被同时加上�Q�需要另外一个操作加上）�Q�然而在Free操作中，tot��g��被同时清�I�，�q�样��׃��D��在对某个�l�点清空�Q�该�l�点包含在某个Free操作要清�I�的�U�段中）�q�打�?标记之后�Q�如果紧接着又插入一条包含这个结点区间的新线�D�，则这个结点的0标记��׃��丧失�Q�这样在紧接着下传的时候，其子�l�点的tot值就不会被清�I�（事实上已�l�被清空了）。所以，��tot域彻底�{�U�d��另一��늺��D�|��里�?
struct node {
    int len, mr, lsc, rsc, sc;
} T[MAXN << 2];
struct node0 {
    int tot;
    bool mr;
} T0[MAXN << 2];
其中lsc、rsc、sc��是�q�箋�I�闲�D늚�长度�Q�用左右归中的方法维护）�Q�mr是一个整体赋值标讎ͼ�在T中，mr的��D��?1表示无标讎ͼ�未被整体赋��|��Q�若�?表示被整体清�I�，若大�?表示整体被一条线�D�覆盖，mr值就是这条线�D늚��~�号�Q��ؓ区分不同�U�段�Q�这里按照输入顺序对每一条New操作插入的线�D�以1�?……�~�号�Q�，在T0中，mr=1表示在Reset中被整体清空�Q�mr=0表示无标记�?br /><2>操作处理�Q?br />1)Reset操作�Q�将T、T0的根�l�点打上清空标记卛_��Q?br />2)New�Q�涉及到两个操作�Q�分别是找最左的长度为x的连�l�空闲段�Q�以及插入一条线�D�c��对于前者，可以�Ҏ��lsc、rsc、sc的��|��按照“先左子结点，再跨��两个子�l�点�Q�最后右子结�?#8221;的顺序求得（详见代码�Q�；对于后者就不用说了�Q�太�Ҏ��实现了（注意标记的处理以及upd�Q�另外要插入一个tot�Q�；
3)Free�Q�也涉及两个操作�Q�分别是找一个点x所在的�U�段�Q�插入过的线�D�）长度以及删除一条线�D�，对于前者可��New插入�q�的所有线�D늚�左右端点预存��h��Q�然后找��C��表区间[x, x]的结点的mr��|��也就是结点x被编号�ؓ��马的线�D�覆盖）�Q�再在预存的�U�段中找到即可。对于后者，直接清空卛_��Q�不要在T0中打标记�Q�而要单独删除一个tot�Q�；
4)Get�Q�直接利用T0中的tot扑ֈ��W�K��的值即可；

代码

Mato_No1 2011-12-18 08:58 发表评论

Mato_No1 — Mon, 27 Jun 2011 12:54:00 GMT
首先�Q�Orz一下AHdoc��犇�Q�本沙茶是看他的�ȝ��才搞懂划分树的�?br />原文地址

划分树，��是每个�l�点代表一个序列，设这个序列的长度为len�Q�若len>1�Q�则序列中前len/2�Q�上取整�Q�这里数学公式不好打�Q�真囧）个元素被分到左子�l�点�Q�左子结点代表的序列��是�q�些元素按照根结点中的顺�?/strong>�l�成的序列，而剩下的元素被分到右子结点，叛_��l�点代表的序列也��是剩下的元素按照根�l�点中的��序�l�成的序列；若len=1�Q�则该结点�ؓ叶结炏V��划分树最重要的应用就是找区间�W�K��（只是查找�Q�不包括修改�Q��?br />
写划分树时主要有两个函数�Q�徏树和扑֌�间第K��。由于后者AHdoc��犇已经�ȝ��了，所以这里只�ȝ��建树的函数�?br />
讄��前结点�ؓ[l..r]�Q�l>1。然后可以得刎ͼ�[l..r]中小于中值的的元素一定被划分到左子结点，[l..r]中大于中值的元素一定被划分到右子结点，而[l..r]中等于中值的元素则不��定�Q�有的被划分到左子结点，有的被划分到叛_��l�点�Q�这��需要先扑ֈ�应被划分到左子结点的�{�于中值的元素个数sm�Q�从mid开始不断往左，直到扑ֈ�边界处或者找��C��个小于中值的元素为止�Q�或者说�Q�sm��是a0[l..mid]中等于中值的元素个数�Q�，然后开始划分，��于中值分到左子结点，大于中值分到右子结点，�{�于中值的�Q�若目前�q�没满sm则分到左子结点否则分到右子结炏V��另外中间有两个值需要记录（扑֌�间第K��时必须要用刎ͼ��Q�sl和sr。sl[i]表示[l..i]中被分到左子�l�点的元素个敎ͼ�sr[i]表示[l..i]中被分到叛_��l�点的元素个敎ͼ��q�里l<=i<=r。显然sl[i]+sr[i]=i-l+1�Q�其实sr[i]可以不用记录的，�q�里只是��Z��在找�W�K��操作中减少计算�ơ数�Q��v到空间换旉��的作用）�?br />建树代码�Q?
int mkt(int l, int r, int d)
{
    T[++No].l = l; T[No].r = r; int mid = l + r >> 1; T[No].mid = mid;
    if (l == r) return No;
    int midv = a0[mid], sm = mid - l + 1; rre2(i, mid, l) if (a0[i] < midv) {sm = mid - i; break;}
    int x = l, y = mid + 1;
    if (a[d][l] < midv) {
        a[d + 1][x++] = a[d][l]; sl[d][l] = 1; sr[d][l] = 0;
    } else if (a[d][l] == midv && sm) {
        a[d + 1][x++] = a[d][l]; sl[d][l] = 1; sr[d][l] = 0; sm--;
    } else {
        a[d + 1][y++] = a[d][l]; sl[d][l] = 0; sr[d][l] = 1;
    }
    re3(i, l+1, r) {
        if (a[d][i] < midv) {
            a[d + 1][x++] = a[d][i]; sl[d][i] = sl[d][i - 1] + 1; sr[d][i] = sr[d][i - 1];
        } else if (a[d][i] == midv && sm) {
            a[d + 1][x++] = a[d][i]; sl[d][i] = sl[d][i - 1] + 1; sr[d][i] = sr[d][i - 1]; sm--;
        } else {
            a[d + 1][y++] = a[d][i]; sl[d][i] = sl[d][i - 1]; sr[d][i] = sr[d][i - 1] + 1;
        }
    }
    int No0 = No; T[No0].lch = mkt(l, mid, d + 1); T[No0].rch = mkt(mid + 1, r, d + 1); return No0;
}
�q�里a是每层划分后的序列�?br />查找区间�W�K��的代码�Q?
int Find_Kth(int l, int r, int K)
{
    int i = root, d = 0, l0, r0, mid0, s0, s1;
    while (1) {
        l0 = T[i].l, r0 = T[i].r; mid0 = T[i].mid;
        if (l0 == r0) return a[d][l];
        if (l == l0) s0 = l; else s0 = l0 + sl[d][l - 1]; s1 = l0 + sl[d][r] - 1;
        if (K <= s1 - s0 + 1) {
            i = T[i].lch; l = s0; r = s1; d++;
        } else {
            K -= (s1 - s0 + 1); if (l == l0) l = mid0 + 1; else l = mid0 + sr[d][l - 1] + 1;
            r = mid0 + sr[d][r]; i = T[i].rch; d++;
        }
    }
}

【具体题目�?a title="PKU2104" >PKU2104�?a title="PKU2761" >PKU2761�Q�两道�Q选一道）

Mato_No1 2011-06-27 20:54 发表评论

Mato_No1 — Sat, 07 May 2011 06:12:00 GMT
考虑�q�样一�U�网�l�流问题�Q�需要对同一个图求多�ơ最大流。则在每�ơ求最大流之前�Q�需要将所有边的容量全部恢复到初始��|��求最大流的过�E�中�Q�边的容量f��D��改变了）。不�q�这�q�不��最猥琐的，有的时候，我们需要在每次求最大流之前都删��d��中的一些点或一些边�Q�或者改变某些原有的边的定w��Q�特别是需要删�Ҏ��删边的情�늈�难搞。因为，一般的边表中边�c�d��定义如下�Q?br />
struct edge {
        int a, b, f, next;
} ed[MAXM + MAXM];
表示�q�条边�v点�ؓa�Q�终点�ؓb�Q�容量�ؓf�Q�邻接边�Q�就是下一条�v点�ؓa的边�Q�的�~�号为next�?br />如果要求多次最大流�Q�那么在每次求最大流之前��p��把所有边的容量恢复到初始��|��解决�Ҏ��是引入一�?#8220;初始定w��”域fs�Q�在�q�条边刚刚被加入的时候将它的fs值和f值都设�ؓ初始�l�它的容量，在恢复时�Q�只要将所有边的f值恢复到fs卛_��。若要改变边定w��Q�则��该边的fs值和f值都设�ؓ改变后的定w��卛_��?br />
下面来分析需要删�Ҏ��删点的情��c��在�q�种情况下，如果采用只有next的单向链表，则删除时next域极隑֤�理，而且�Q�在一般的边表中，�q�设立了表头hd�Q�hd[a]表示边表中�v点�ؓa的第一条边的编受��因此，若删除的�?lt;a, b, f>是�v点�ؓa的第一条边�Q�还会媄响hd[a]的��|��使情况变得更为复杂。因此，必须采用双向链表�Q�还记得Dancing Link么？边表其实也可以搞成Dancing Link�Q�方法如下：
讑֛�中有N个点�Q�M条边�Q�注意，�q�M条边只包括正向边�Q�不包括反向辏V��由于每条正向边都对应一条反向边�Q�因此边表中边的数目其实是M+M�Q�。首先把边表ed�?~N�q?N+1)个位�|�（下标�Q�空出来�Q�作表头�Q�表头不是边�Q�因此在遍历边的时候不会遍历到它们�Q�。其中，ed[0]为总表��_��用于遍历ed[1..N]中每个未被删�ȝ��点；ed[1..N]为单点表��_��ed[i]用来遍历图中所有以i��v点的边（和DLX中的二维DL惊�h�怼��Q�。然后，若N为偶敎ͼ�则空一个位�|�（也就是将ed[N+1]丢弃不用�Q�，�q�是因�ؓ我们在增�q�过�E�中需要引用到一条边对应的逆向边（正向边对应反向边�Q�反向边对应正向边）�Q�一般认为编号�ؓp的边对应的逆向�Ҏ��p ^ 1�Q�这��P��p��求图中所有正向边的编号都是偶敎ͼ�所有反向边的编号都是奇敎ͼ�否则会造成混�ؕ�Q�。因此当N为偶数时�Q?N+1)为奇敎ͼ�不能攄��W�一条正向边�Q�需要从ed[N+2]开始放�|�正向边。若N为奇数则不用�I�Z��?br />接下来就是边�c�d��了。在�q�里�Q�边�c�d��一共需要包�?个域�Q�a, b, fs, f, pre, next�Q�表�C��条边��L��为a�Q�终点�ؓb�Q�初始容量�ؓfs�Q�当前容量�ؓf�Q�上一条�v点�ؓa的边�~�号为pre�Q�下一条�v点�ؓa的边�~�号为next。注意，和DL一��P��整个链表是��@环的�Q�也��是我们认�ؓ表中最后一条�v点�ؓa的边的下一条邻接边�~�号��是a�Q�表��_��Q�同��P��a的上一条邻接边也就是这条边�?br />
struct edge {
    int a, b, fs, f, pre, next;
} ed[MAXM + MAXM];
接下来就是几个重要过�E�了�?br />�Q?�Q�初始化表头�Q?br />
void init_d()
{
    re1(i, n) {ed[i].a = i; ed[i].b = -1; ed[i].f = 0; ed[i].pre = ed[i].next = i;}
    if (n % 2) m = n + 1; else m = n + 2;
}
�q�里n是图中的�Ҏ��Q�相当于N�Q�，m是边的编��h��针（相当于DLX中的nodes�Q?br />�Q?�Q�添加新边：

void add_edge(int a, int b, int f)
{
    ed[m].a = a; ed[m].b = b; ed[m].fs = ed[m].f = f; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].fs = ed[m].f = 0; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
�q�个和DLX�c�M��Q�不解释了囧……

最后进入最核心的部�?#8212;—到底如何处理删边或删点？有了DL型边表就爆好搞了�Q�删��M��条边�Q�只要直接删去该边在DL中的位置卛_��Q?br />
void deledge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
}
恢复一条已删去的边�Q?br />
void resuedge(int No)
{
    ed[ed[No].pre].next = ed[ed[No].next].pre = No;
}
需要删点的情况�c�M��Q�对单点表头处理卛_��?br />
【具体题目�?a title="PKU1815" >PKU1815
�q�题��是求有向图的字典序最��的最��点割集问题�Q�方法是先求出最��点�q�通度�Q�有��x��点�q�通度的求法见囄��q�通度问题的求�?/a>�Q�，然后按编号递增��序枚�D每个点，若删去该点（其实是删��d��成的新图中该点i'到该炚w��加点i''之间的边�Q�后囄��最��点�q�通度减小�Q�则应删去该点，否则不应删去该点。删��d��Q��l�枚举下一个点�Q�直到求出点割集为止�?br />注意�Q�本题只有删边，没有删点�Q�因此总表头可以不需要，直接从ed[0]开始作单点表头。此�Ӟ��关于是否�I�Z��刚好反�q�来了：如果N是奇数就要空位，N是偶��C��I�Z��Q�不�q�这题里�׃��建出的网�l�流图中�?*N0个结点，��L��偶数�Q�可以不��，不过本沙茶还是管�q�个了）�?br />
代码�Q�神犇不要鄙视）�Q?br />
#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 501, MAXM = 100000, INF = ~0U >> 2;
struct edge {
    int a, b, fs, f, pre, next;
} ed[MAXM + MAXM];
int n0, n, m = 0, s, t, start[MAXN], pr[MAXN], hs[MAXN], lev[MAXN], q[MAXN], now, flow, reslen = 0, res[MAXN];
bool vst[MAXN];
void init_d()
{
    re(i, n) {ed[i].a = i; ed[i].b = -1; ed[i].f = 0; ed[i].pre = ed[i].next = i;}
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int f)
{
    ed[m].a = a; ed[m].b = b; ed[m].fs = ed[m].f = f; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].fs = ed[m].f = 0; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
void init()
{
    int x;
    scanf("%d%d%d", &n0, &s, &t);
    n = n0 << 1; s--; t += n0 - 1; init_d();
    re(i, n0) re(j, n0) {
        scanf("%d", &x);
        if (i == j) {
            if (i == s || i == t - n0) add_edge(i, i + n0, INF); else add_edge(i, i + n0, 1);
        } else if (x) add_edge(i + n0, j, INF);
    }
}
void aug()
{
    int z = hs[t], i = t, p; flow += z;
    while (i != s) {
        hs[i] -= z; p = pr[i]; ed[p].f -= z; ed[p ^ 1].f += z; i = ed[p].a;
        if (!ed[p].f) now = i;
    }
}
bool dfs()
{
    re(i, n) vst[i] = 0; vst[s] = 1; q[0] = s; lev[s] = 0;
    int i, j, f0;
    for (int front=0, rear=0; front<=rear; front++) {
        i = q[front];
        for (int p=ed[i].next; p != i; p=ed[p].next) if (ed[p].f) {
            j = ed[p].b;
            if (!vst[j]) {vst[j] = 1; q[++rear] = j; lev[j] = lev[i] + 1;}
        }
    }
    if (!vst[t]) return 0;
    now = s; re(i, n) {start[i] = ed[i].next; vst[i] = 0;} hs[now] = INF;
    bool fd;
    while (!vst[s]) {
        if (now == t) aug();
        fd = 0;
        for (int p=start[now]; p != now; p=ed[p].next) {
            j = ed[p].b; f0 = ed[p].f;
            if (lev[now] + 1 == lev[j] && !vst[j] && f0) {
                fd = 1; start[now] = pr[j] = p; hs[j] = hs[now] <= f0 ? hs[now] : f0; now = j; break;
            }
        }
        if (!fd) {
            vst[now] = 1;
            if (now != s) now = ed[pr[now]].a;
        }
    }
    return 1;
}
void deledge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
}
void resuedge(int No)
{
    ed[ed[No].pre].next = ed[ed[No].next].pre = No;
}
void resu_all()
{
    re(i, n) for (int p=ed[i].next; p != i; p=ed[p].next) ed[p].f = ed[p].fs;
}
void solve()
{
    flow = 0; while (dfs()) ; int f_ = flow;
    if (!flow) {reslen = -1; return;}
    re(i, m) if (ed[i].a + n0 == ed[i].b && ed[i].a != s && ed[i].b != t) {
        deledge(i); deledge(i ^ 1); resu_all();
        flow = 0; while (dfs()) ;
        if (flow < f_) {res[reslen++] = ed[i].a + 1; f_--;} else {resuedge(i ^ 1); resuedge(i);}
    }
}
void pri()
{
    if (reslen == -1) puts("0"); else if (reslen) {
        printf("%d\n", reslen);
        re(i, reslen - 1) printf("%d ", res[i]); printf("%d\n", res[reslen - 1]);
    } else puts("NO ANSWER!");
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

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

用A*求图的单源单汇第K短�\

Mato_No1 — Sun, 01 May 2011 07:25:00 GMT
【问题描�q��?br>�l�出一个图G和指定的源点s、汇点t�Q�求图中从点s到点t的第K短�\�?br>【具体题目�?a title=PKU2449 >PKU2449�Q�注意：本题有一个猥琐之处：不允许空路径。也��是当s�{�于t时要��K值加1�Q?br>【算法�?br>本题有一�U�最朴素的办法：攚w��Dijkstra�Q�一开始�\�?s, 0)�Q�这里设路径(i, l)表示从s到i的一条长度�ؓl的�\径）入队。然后，每次取队中长度最短的路径�Q�该路径(i, l)出队�Q�可以证明，若这是终点�ؓi的�\径第x�ơ出队，该�\径一定是图中从s到i的第x短�\�Q�若x>K则该路径已无用，舍弃�Q�。然后从点i扩展�Q�将扩展到的路径全部入队。这��L��到终点�ؓt的�\径第K�ơ出队即可�?br>该算法容易实玎ͼ�借助priority_queue�Q�，但时间复杂度可能辑ֈ�O(MK)�Q�需要优化�?br>优化�Q�容易发现该��法其实有A*的思想�Q�或者说�Q�该��法其实是所有结点的��C�h函数h()值均�?的A*��法。�ؓ了优化此题，需要将h()值改大。显�Ӟ��h(i)值可以设�?span style="COLOR: red">从i到t的最短�\径长�?/strong>�Q�容易证明它是一致的�Q�，然后g(i)=目前�l�点代表的�\径长度，f(i)=g(i)+h(i)�Q�然后A*卛_��?br>
注意�Q�更改�\径条数应该在出队时更改，而不能在入队时更改，因�ؓ可能在该路径出队之前会有新的比它更短的�\径入队�?br>
代码�Q�PKU2449�Q�：

#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 1500, MAXM = 150000, INF = ~0U >> 2;
struct edge {
    int kk, len, next;
} ed[MAXM], ed2[MAXM];
int n, m, s, t, k_, hd[MAXN], tl[MAXN], hd2[MAXN], tl2[MAXN], h[MAXN], q[MAXN + 1], No[MAXN], res = -1;
bool vst[MAXN];
struct qnode {
    int i, g;
};
typedef priority_queue <qnode, vector<qnode> > pq;
pq z;
bool operator< (qnode q1, qnode q2)
{
    return q1.g + h[q1.i] > q2.g + h[q2.i];
}
void init()
{
    int a0, b0, l0;
    scanf("%d%d", &n, &m);
    re(i, n) hd[i] = tl[i] = hd2[i] = tl2[i] = -1;
    re(i, m) {
        scanf("%d%d%d", &a0, &b0, &l0); a0--; b0--;
        ed[i].kk = b0; ed[i].len = l0; ed[i].next = -1;
        if (hd[a0] == -1) hd[a0] = tl[a0] = i; else tl[a0] = ed[tl[a0]].next = i;
        ed2[i].kk = a0; ed2[i].len = l0; ed2[i].next = -1;
        if (hd2[b0] == -1) hd2[b0] = tl2[b0] = i; else tl2[b0] = ed2[tl2[b0]].next = i;
    }
    scanf("%d%d%d", &s, &t, &k_); --s; --t; k_ += s == t;
}
void prepare()
{
    re(i, n) {h[i] = INF; vst[i] = 0;} h[t] = 0; vst[t] = 1; q[0] = t;
    int i, h0, j, h1;
    for (int front=0, rear=0; !(!front && rear == n || front == rear + 1); front == n ? front = 0 : front++) {
        i = q[front]; h0 = h[i];
        for (int p=hd2[i]; p != -1; p=ed2[p].next) {
            j = ed2[p].kk; h1 = h0 + ed2[p].len;
            if (h1 < h[j]) {
                h[j] = h1;
                if (!vst[j]) {vst[j] = 1; if (rear == n) q[rear = 0] = j; else q[++rear] = j;}
            }
        }
        vst[i] = 0;
    }
}
void solve()
{
    qnode q0; q0.i = s; q0.g = 0; z.push(q0);
    re(i, n) No[i] = 0;
    int i, d0, j, d1;
    while (!z.empty()) {
        i = z.top().i; d0 = z.top().g; z.pop();
        if (No[i] >= k_) continue;
        No[i]++;
        if (i == t && No[i] == k_) {res = d0; break;}
        for (int p=hd[i]; p != -1; p=ed[p].next) {
            j = ed[p].kk; d1 = d0 + ed[p].len;
            q0.i = j; q0.g = d1; z.push(q0);
        }
    }
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-05-01 15:25 发表评论

Mato_No1 — Sun, 24 Apr 2011 07:50:00 GMT
     摘要: 动态区间最大子序和问题【问题描�q�】给��Z��个序列A[0..N-1]和M个操作，每个操作都是以下三种之一�Q�①�Q�查询区间最大子序和操作格式�Q? l r表示�Q�查询A[l..r]内的最大子序和�Q�就是A[l..r]内的和最大的�q�箋子序列的和）�Q?<=l<=r阅读全文

Mato_No1 2011-04-24 15:50 发表评论

Mato_No1 — Sat, 23 Apr 2011 08:09:00 GMT
【问题描�q��?br>�l�出一个环形的字符串S�Q�长度�ؓN�Q�现在要扑ֈ�一个断开点，使得从这里断开后的字符串字典序最��。或者说�Q�对于长度�ؓN的字�W�串S[0..N-1]�Q�找��C��个位�|�i�Q��得字�W�串S' = S[i..N-1] + S[0..i-1]的字典序最��。若存在多个�q�样的最优断点，则取最左边(i最��?的那个�?br>【Sample Input�?br>amandamanda
【Sample Output�?br>10
�Q�从�W?0位断开后得到的字符�?aamandamand"的字典序�?1个断开位置中最��的�Q?br>
【分析�?br>首先��这个环形串拆开�Q�只需��S[0..N-1]的后面再接上S[0..N-2]卛_��Q�如对于样例�Q�可构造字�W�串T = "amandamandaamandamand"�Q�，则T的�Q意一个长度�ؓN的子串T[i..i-N+1]��是S从第i位断开得到的字�W�串。此旉��题就变成了：�l�出一个长度�ؓ(2N-1)的字�W�串�Q�求出其所有长度�ؓN的子串中字典序最��的�?br>
设F[x]�?span style="COLOR: red">T中所有�v始位��于N的长度�ؓx的子串中字典序最��的子串的�v始位�Q�若有多个则取最左边的）�Q�如对于T="abaabaaababaabaaa"�Q�有F[0]=F[1]=0�Q�F[2]=2�Q�F[3]=F[4]=5……本题的目的就是求出F[N]的倹{��一开始已知的只有F[0]=0�Q�长度�ؓ0的字�W�串都是�I�Z��Q�字典序都是最��的�Q�取最左边的第0位）�?br>
可以发现�Q�F数组有很多重要的性质�Q?br>性质1 F[0..N]数组是单调递增的�?/strong>
证明�Q�用反证法。设存在一个值x(0<=xF[x+1]则根据定义，有T[F[x+1]..F[x+1]+x]<=T[F[x]..F[x]+x]�Q�这里一定不会越界，即F[x]+x的��g��定不大于(2N-1)�Q�因为xT[F[x]..F[x]+x-1]�Q�否则F[x]的值就应该�{�于F[x+1]的��g��Q�，矛盾�Q�故在F[0..N]中不可能存在��M��F[x]>F[x+1]的情况，也即F[0..N]数组是单调递增的（以下��F[0..N]数组��U�CؓF数组�Q��?br>性质2 对于��L��值x(0<=xF[x]+x�?/strong>
证明�Q�因为前面已�l�证明了F数组是单调递增的，�q�里只需证明对于��L��x(0<=x�q�里同样用反证法。设存在一个值x(0<=xF[x]+x�?br>
�Ҏ��F数组的以上两个性质可以设计出本题的��法�Q?br>讄��前已�l�求��Z��F[0..x-1]的��|��且F[x-1]=i。首先将T[0..i-1]全部删去�Q�因为F数组是单调递增的，F[x]的��g��定不��于i�Q�，然后对T自��n作扩展KMP�Q�就是以T为模板串�Q�T为子串的扩展KMP�Q�相当于光��处理部分�Q�，一开始先��F[x]�|��ؓi�Q�设�W�j位的匚w��长度为next[j]�Q�若next[j]=x-1且T[j+x-1]
旉��复杂度：O(NÖN)�Q�可以根据性质2得到�?

Mato_No1 2011-04-23 16:09 发表评论

RMQ问题

Mato_No1 — Sat, 26 Mar 2011 02:13:00 GMT
今天�l�于搞懂了RMQ问题无比��犇的ST��法……

【离�U�RMQ问题�?br>题意�Q�对于一个序列A[1..N]�Q�共有M�ơ提问，每次都是问A[l..r]�Q?<=l<=r<=N)中的最��|��求出每次提问的答案�?br>
�Q?�Q�纯暴力枚�D�Q�O(NM)�Q?br>�Q?�Q�树状数�l�：O(M(logN)^2)【见树状数组解决��ȝ��RMQ问题�?br>�Q?�Q�ST��法�Q�O(MlogN)……
ST��法是基于分块DP的�?br>设F[i][j]为A[i..(i+2^j-1)]�Q�共2^j个元素）中的最��|��前提是不能越界，即i+2^j-1 <= N�Q�，昄��F可以通过DP的方式得刎ͼ�
F[i][j] = min||max{F[i][j-1], F[i+2^(j-1)][j-1]}
边界�Q�F[i][0]=A[i]�?br>DP求F的值的旉��复杂度�ؓO(NlogN)�Q�一共只有NlogN个F值有意义�Q�；

然后�Q�对于求A[l..r]中的最��|��只要��A[l..r]拆成若干�q�箋的段�Q��得每�D늚�长度都是2的整数次�q�就行了�Q�比如A[3..28]可以拆成A[3..18]、A[19..26]、A[27..28]三段�Q�长度分别是16�Q?^4�Q��?�Q?^3�Q��?�Q?^1�Q�，所以min||max{A[3..28]} = min||max{F[3][4], F[19][3], F[27][1]}�?br>关键是怎么拆？�Ҏ��Q�求�?r-l+1)�Q�即A[l..r]的长度）的二�q�制形式�Q�然后从高位��C��位依�ơ遍历，如果扑ֈ�1位就加上目前的位对应的幂�Q�如(28-3+1)=(11010)2�Q�所以依�ơ找到F[3][4]、F[3+2^4][3]、F[3+2^4+2^3][1]。注意此旉��要预先设一个数�l�B�Q�B[2^i]=i�Q�以方便扑ֈ�某个取出的幂对应的指数�?br>昄��Q�最多只有logN�D�，所以一�ơ提问的旉��复杂度�ؓO(logN)�?br>
其实�q�有一�U�方法，��是先求出log(r-l+1)的��|��下取��_��Q�设为x�Q�然后F[l][x]和F[r-2^x+1][x]中的较大/较小值就是A[l..r]中的最倹{��这��P��一�ơ提问的旉��复杂度就降到了O(1)。问题是�Q�系�l�log函数灰常慢，也许��一�ơlog函数值的旉��已经��过了logN�Q�这��h��然得不偿失。所以仍然推荐上面的�Ҏ��?br>
【核心代码（以求最��gؓ例，最大值类��|��?br>分段法：

int MIN(int l0, int r0)
{
    int min = INF, h = l0, d0, b0;
    for (int d = r0 - l0 + 1; d; d -= d0) {
        d0 = d & -d; b0 = B[d0];
        if (F[h][b0] < min) min = F[h][b0];
        h += d0;
    }
    return min;
}
求log值法�Q?br>
int MIN(int l0, int r0)
{
    int v = (int)floor(log2(r0 - l0 + 1.0)), s1 = F[l0][v], s2 = F[r0 - (1 << v) + 1][v];
    return s1 <= s2 ? s1 : s2;
}
求F数组值的预处理代码（注意�Q�如果采用求log值的�Ҏ��׃��需要B数组了）�Q?br>
void prepare()
{
    re(i, n) F[i][0] = a[i];
    int x;
    re2(j, 1, MAXS) {
        if ((1 << j) <= n) B[1 << j] = j;
        x = n - (1 << j) + 1;
        re(i, x) F[i][j] = min(F[i][j - 1], F[i + (1 << j - 1)][j - 1]);
    }
}

【后�l�效率测试，发现当N=M=100000的随机数据中�Q�两�U�方法都可以�?.4s以内得出正确�l�果�Q�其中log值法比分�D�|��略慢0.01s左右�Q�相差不大，但考虑�?#8220;��量��用数学函�?#8221;的原则，仍推荐分�D�|��?br>

Mato_No1 2011-03-26 10:13 发表评论

欧美成人精品在线,亚洲欧美日韩成人,国产精品久久久久久久久免费樱桃

【AHOI2013复仇】二�l�DP优化的几道题�ȝ��

【AHOI2013复仇】s-t�W�K短简单�\问题

【AHOI2013复仇】两道LIS模型题�ȝ��

【AHOI2013复仇】ZJOI2008 骑士 题解

XOR专题�Q�一�Q�：异或方程�l�的解法

炮兵阵地以及与其相关的一�cȝ��压DP问题

�U�段树操作极品题——HDU2871

用A*求图的单源单汇第K短�\

RMQ问题

【AHOI2013复仇】ZJOI2008 骑士题解