C++博客-Mato is No.1-随笔分类-经典问题的模型

关于树分治的问题

Mato_No1 — Sat, 31 Aug 2013 15:39:00 GMT

摘要: （从NOI以后一直在各网站上做水题……谁叫我这么弱做不动难题呢……）（最近实在感觉到弱得令人吃惊……这样下去还混什么集训队啊……于是只好去挑难题了……中间对某些知识点有一些见解……就总结在这里了囧……）（最近见到了比较多的树分治的题... 阅读全文

Mato_No1 2013-08-31 23:39 发表评论

【AHOI2013复仇】二维DP优化的几道题总结

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

【1】BZOJ1713
F[i][j]=max{F[i1][j1] - (sA[i-1]-sA[i1])² - (sB[j-1]-sB[j1])²} + A[i]*B[j], 0<=i1对这个式子进行化简：
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]²
对于一维的情况，很容易处理——中间就是一条直线，然而这是二维的，对于这种2D/2D的DP方程，要优化到O(N²)级别，需要两步。
注意到决策式中除了F[i1][j1]外，其它部分都要么只与i1有关，要么只与j1有关。因此，可以把阶段i的各个状态作为一个整体，在之前得出的各个F[i][j]中，对于相同的j，找到对于目前的i，最优的那个决策——注意，对于相同的j1，里面所有与j1有关的东西都可以先不考虑了，只考虑(F[i1][j1] - sA[i1]² + 2*sA[i-1]*sA[i1])对于目前i的最优决策。这一步可以在这些直线形成的上凸壳中找到，且满足决策单调性，可以用一个栈处理（斜率优化）。然后，将这些最优决策以j为自变量再组成一些直线，用栈维护它们的上凸壳，对于每个j，找到最优值即可。
注意事项：在栈中删除直线的时候，如果之前的最优决策是这个被删掉的直线，则要将最优决策先置为不存在，然后再插入新直线后设为新直线。另外，要特别注意平行的情况。

【2】LCIS
经典问题，利用上面的分步优化思想，很容易用线段树得到一个O(N²logN)的做法。

【3】[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，计算方法是一样的，且是一条直线（由于有范围所以其实是线段）。
所以，计算阶段i时，可以将(i-W-1)阶段所有的决策当成线段插入，这些线段的斜率都相等，因此比较好维护，只需要判断边界即可。

注意，NOI2011的show虽然也符合对于相同的j计算方法一样，但它就不能优化，因为它的决策是不连续且无规律的，没有任何几何性质。因此，它只能用O(N³)的算法计算出所有状态。

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

【AHOI2013复仇】动态凸包

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

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

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

【AHOI2013复仇】向JZPKIL认输了

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

RT，
今天又优化了一下JZPKIL，用上了各种无耻的手段，仍然无法干掉后两个点，并且BZOJ上的总时间50s也无法实现（后两个点一个就要20s），
看来基于组合数的做法由于要枚举因数，确实不行……
（注：后两个点是人工构造的猥琐数据，所有的N都是若干个小质数之积，因数个数都上千，有的甚至上万……）

认输了……
Orz @sevenk

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

【AHOI2013复仇】s-t第K短简单路问题

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

[SCOI2007 kshort]
求图的s-t第K短简单路问题，若有长度相同的，字典序小的优先。

首先，由于是简单路，所以A*是不能做的，因为有可能有两条s-i（i为某个中间点）路P1和P2，P1比P2短，但由于P1到达的顶点与P2不同，导致最终沿P1到达t的路径长度长于沿P2到达t的（甚至有可能沿P1根本到不了t）。然后，如果直接用DFS，由于要求的是第K优解，而不是最优解，所以不能使用最优性剪枝（包括分支限界），因此专门为最优性剪枝服务的“改变搜索顺序”技巧也不能使用了，因此，能够使用的只有可行性剪枝，而本题的数据范围使得这种算法必然TLE。

正解是一种由迭代加深思想扩展得到的“迭代变优”DFS。设置一个路径长度上限Z，搜索s到t的所有简单路，在搜索过程中，遇到长度大于Z的路径就停止（剪枝），然后，若得到路径不足K条，则增加Z的值，重新开始搜索，直到得到的路径总数大于等于K条为止。这里可以进行启发式的优化，设g[i]为点i到t的最短路长度，则搜索过程中，假设目前搜到点i，则（目前路径长度+g[i]）是对整条路径最短长度的乐观估计，如果这个值超过了Z，就可以剪枝，但在剪枝之前要记下这个超过了Z的启发值，取其中最小的作为下一次迭代的Z值。那么对于字典序肿么办？可以在搜索过程中，强制先搜编号小的结点，这样得到的s-t路径必然是字典序递增的。另外只要求出第K条路径，搜索就可以终止，因为容易证明，题目要求的第K短的路径一定已经求出来了（只不过不一定是最后一条而已），找到即可。此外，在搜索过程中不要忘了可行性剪枝，就是如果沿目前搜到的路径已经到不了t了，剪枝。

“迭代变优”DFS，就是设置一个解的评价值的上限（最小值）或下限（最大值），在搜索过程中，如果实际评价值（或者启发值，如果可以加启发式优化的话）越过这个限制，则剪枝。在一次搜索后，如果没有得到符合要求的解，就将该限制值设为本次搜索过程中越界“越”得最近的那个值，重新开始搜索，直到找到所需要的解或者发现无解（如果一次搜索中没有发生越界，却仍然没有找到解）为止。其应用主要体现在两个方面：（1）搜索树过深甚至无限深，但所需求的那个解却不深的情况；（2）求第K优解的情况。

代码：

#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

最近做了两道LIS模型题，感觉到模型比较好，总结一下囧。
【1】[HAOI2007]上升序列
预处理：设F[i]为以i开头的最长上升序列的长度，怎么求不用说了吧囧……
假设目前需要求长度为M的、标号字典序最小的上升序列，显然其第一个元素A[i]必须满足F[i]>=M（注意，不是等于，是大于等于！），找到满足这个条件的最小的i即可。然后，设目前已经求出了该序列的第x个元素为A[y]，则第(x+1)个元素A[z]需要满足的条件是A[z]>A[y]，且F[z]=F[y]-1，找到满足这个条件的最小的z即为该序列的第(x+1)个元素。按照这种方法，扫描一遍就可以求出整个序列，时间复杂度为O(N)。如果整个序列的最长上升序列长度
代码：

【2】[HAOI2006]数字序列
首先，由于序列的所有元素都是整数，所以可以将原序列的所有元素减去它的下标，这样就把上升序列转化为不下降序列了。
第一问的结果显然就是(N-新序列的最长不下降序列长度)。关键在于第二问。以下A均表示新序列。
设F[i]为以A[i]结尾的最长不下降序列长度（同样，求法不用说了），G[i]为在A[i]不修改的前提下将A[0..i]转变为不下降序列的最小修改量。首先求出F[i]，然后在求G[i]时，枚举上一个“不动点”（就是不修改的元素）A[j]（显然必须满足A[j]<=A[i]且F[j]=F[i]-1），这样最小修改量就是G[j]+(将A[j..i]转变为不下降序列的最小修改量）。可以证明，A[j..i]的最优修改方案必然是将A[j+1..t]全部修改为A[j]，A[t+1..i]全部修改为A[i]，这里t是一个[j..i]范围的值。问题就是如何求出最优的t？
一开始，假设t=j，即把A[j+1..i-1]全部修改为A[i]，计算出修改量，设为S。然后，由于A[j+1..i-1]之间的元素要么小于A[j]，要么大于A[i]（这个是显然的囧），我们把小于A[j]的元素称为“小数”，把大于A[i]的元素称为“大数”，则当t取t0时，修改量为S-(A[i]-A[j])*(A[j+1..t0]中的“小数”个数减去“大数”个数）。这样，只需扫描一下，求出使得(A[j+1..t0]中的“小数”个数减去“大数”个数）值最大的t0即可。
当然还有一个问题，对于同一个i，满足“A[j]<=A[i]且F[j]=F[i]-1”的元素个数可能有很多，如果一个一个枚举，一个一个扫描，会很慢的囧……解决方法是，求出满足这个条件的j中最小的一个，设为j0，然后把A[j0+1..i-1]中的所有“小数”和“大数”全部处理出来，然后用类似前缀和的方法就能搞了囧……当然，为了找到j0，需要建一个二分图，边为(F[i], i)。
最后，为了方便，可以把A序列的左边加一个-INF，右边加一个+INF。最后总的时间复杂度，理论上为O(N²)，但由于是随机数据，所以远远达不到这个级别。

代码：

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

【AHOI2013复仇】ZJOI2008 骑士题解

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

原题地址
本沙茶的第一个无向环套树模型，纪念一下……

环套树，指的是每个连通块中点数都等于边数的无向图（称为无向环套树）或者是每个点有且只有一个前趋（称为内向环套树）或后继（称为外向环套树）的有向图，由于这个图的每个连通块当中有且只有一个环（注意，可能是自环，即长度为1的环），且这个环上的每个点都可以当作根引出一棵树，所以叫“环套树”。

对于无向环套树，先将整个图进行一次DFS，当中如果发现有逆向边（这条边第一次被发现必然是作为逆向边的，也就是起点是终点的后代），就说明找到了这个环，记录其起点和终点（注意，如果有多个连通块的话，不能退出，要继续遍历完），再不断上溯（因此在DFS过程中当然要记录父边了囧），就可以找到整个环了，然后再以环上的结点为根建树即可，这样依次处理每个连通块。

对于内向环套树（外向类似），找环更为简单，只需要任选一个点，不断去找它的前趋，同时记录找到的点序列，直到某个点在序列中出现两次为止，此时这个点以及序列中它两次出现的位置中间的所有点，就是环上的点，顺序也顺便记录下来，然后树也不用建了，直接在原图中找就行了。

对于这题，由于每个点都有且只有一个后继，所以是外向环套树，不过本沙茶更倾向于它的基图（无向图，是无向环套树），然后就是一个DP了囧……

代码：

#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专题（一）：异或方程组的解法

Mato_No1 — Sun, 20 May 2012 02:17:00 GMT

摘要: 【异或（XOR）运算由于与“奇偶性”密切相关，经常出现在有关奇偶性和二进制的题目中】很多异或问题都要涉及到解异或方程组，因此首先要搞懂异或方程组的解法。（1）异或方程组的格式（设有n个未知数，m个方程）：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 发表评论

炮兵阵地以及与其相关的一类状压DP问题

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

原题地址
说实话我第一次尝试写炮兵阵地是在2009年……已经过去两年多了，终于找到了一个好的解法……庆祝一下……

【状态压缩DP】
所谓状态压缩DP，就是对于某些DP问题，每一阶段的状态都有很多维，要利用某些手段将它们压缩到一维（一个正整数），顺便进行状态的精简（去掉不合法的状态），然后再进行DP。这里讲的主要是传统的状压DP，有一种基于“插头”的DP，更高级，以后再搞。
对于本题，可以设计出一个这样的状态：[0..1][0..1][0..1]...[0..1]（有M个[0..1]），表示该行的每个格子放不放炮兵，如果放，为1，否则为0。显然，这是一个M位二进制数，如果能把它们压缩成一个int就好了。

【如何压缩】
第一个问题是这么多维的状态如何压缩的问题。
对于本题，由于是二进制数，直接压缩就可以了。但是对于某些情况，状态是个三进制数（每个格子的属性都有3种）甚至更多进制数，这样，直接压缩会导致无法使用位运算，从而使“解压”变得很麻烦，耗时也很长（需要暴力），因此，可以将每位三进制都拆成两位二进制：
0->00
1->01
2->10
（当然1拆成10、2拆成11也木有问题，只要能区分开就行了）
这样，每个状态就可以用2个二进制数来表示，可以在构造出所有合法状态以后将每个状态所对应的两位二进制数存到struct里面，使用时调出即可。

【如何精简】
这个问题是最重要的，因为，如果不精简，在枚举状态以及转移的时候就会枚举到很多不合法状态，导致时间浪费。
所谓精简，是指在预处理以及DP过程中，尽量避开不合法状态。
（1）预处理中的精简：
包括3个部分：
<1>找到所有可能的合法状态并编号：根据题意限制，有的状态在阶段内就不合法（比如本题，一行一阶段，那么凡是有两个1位的距离小于2的状态都不合法），而且这种状态所占的比重往往还很大（本题中，M=10时，也只有60种可能的合法状态），此时，为了找到这些合法状态，可以DFS构造实现。
需要注意的是，有的题不光要找到一个阶段内的合法状态，还要找到两个或两个以上阶段内的合法状态（比如那个有关多米诺骨牌的题），此时需要两个int同时DFS；
在找到合法状态以后，需要对每个合法状态进行编号，以达到“压缩”的目的。这里就涉及到了状态编号和状态表示的问题：比如，状态1001，表示为9，在DFS中第一个被搜到，因此编号为0，不要搞混了这两个（尤其不要搞混“编号为0”和“状态表示为0”，它们是不同的）。在预处理和DP的过程中，所有涉及到状态的数组下标，全部是编号而不是表示，知道编号要求表示，可以在DFS中记录的数组里面调，而知道表示要求编号，可以利用逆数组或者哈希；
<2>找到每一阶段的合法状态：即使是<1>中被判定为合法的状态，在具体的各个阶段中也未必合法（比如本题，如果某一行的某一个位置是'H'，不能放，而某一个状态在这里放了，则不合法），因此要对每个阶段再枚举一遍，找到真正合法的状态，并计入一个vector；
<3>找到状态转移中的合法状态：在状态转移中，往往要求状态不冲突（比如本题，在连续的三个阶段中，都不能有某一位有两个为1的情况），因此，还要枚举每个状态在转移时与其不冲突的状态，并计入vector。
注意，有时候这一步不是很容易进行，需要在DP过程中进行；
（2）DP过程中的精简：
DP过程中，枚举状态、转移决策都只枚举合法的，在vector里面调（注意vector里记录的全都是状态编号而不是表示！），可以大大减少枚举量，不过有时候，还会有一些时间浪费，这时候，可以采取一些其它的办法来精简，比如再次进行DFS构造合法状态等。

总之，这类问题的目标就是“精简，精简，再精简，使枚举到的不合法状态减到最少”。

代码：

#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 发表评论

线段树操作极品题——HDU2871

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

原题地址
这是一道线段树操作的极品题，因为它的4个操作刚好覆盖了线段树操作问题的3种处理思路，可以说是把线段树操作的全部内容都包含进去了。

线段树是一种静态的数据结构，因为一棵线段树一旦建成，其形态就永远不会发生变化，改变的仅仅是结点上记录的各种信息的值。因此，对于线段树操作，核心问题也就是如何维护和处理这些信息。总的来说，对于线段树结点信息的维护和处理，有以下3种基本思路：
（1）左右归中型：
所谓左右归中，就是用左右子结点存储的信息来得到父结点存储的信息的值，这是最常见的线段树维护方法。举一些简单的例子：比如结点的SUM域表示该结点区间上所有元素的和，那么这个域维护的方法就是“父结点SUM=左子结点SUM+右子结点SUM”，再比如结点的MAX/MIN域表示该结点区间上所有元素的最大/小值，那么维护方法就是“父结点MAX/MIN=max/min{左子结点MAX/MIN,右子结点MAX/MIN}”。这种维护方法也比较简单，只要在每次对子结点进行修改之后upd一下就行了（对于那些自顶向下递归，而且涉及到改值的操作，在递归完左右子结点后一定要记得upd一下），在这之中有一个很重要的思想就是“左右连续段”思想：如果题目中要求任意一个区间内的具有某种性质的最长的连续序列（也就是子区间），比如最长连续上升子序列、01值问题中连续的0段或者非0段（在具体问题中就是连续的空闲段或者占用段）等，可以在每个结点上维护三个域：lS、rS和S，分别表示该结点区间左端（从区间的最左端开始的）具有这种性质的最长连续序列的长度，该结点区间右端（到区间的最右端结束的）具有这种性质的最长连续序列的长度和该区间内具有这种性质的最长连续序列的长度（也就是要求的那个东东），则维护方法为“父结点lS=左子结点lS（左子结点lS<左子结点len）或左子结点len+右子结点lS（左子结点lS=左子结点len），父结点rS类似，父结点S=max{左子结点S,右子结点S,左子结点rS+右子结点lS}”，此外，由于要求的这个区间可能被拆成多个连续的结点区间，因此需要按顺序合并这些区间，合并的方法是：设立S0和S1，S0表示不保证能延伸下去的区间长度，S0=上一个区间的S1+本区间的lS；S1表示可以延伸下去的区间长度，S1=上一个区间的S1+本区间len（如果本区间整个都是满足条件的，即S=len）或本区间的rS（本区间不都是满足条件的，即S在HDU2871中，应用左右归中的方法维护的信息就是“最长连续空闲段”的长度，New操作需要；

（2）调整边界型：
考虑这样一个问题：现在要插入、删除一些[0, 100000)的整数，并且在此过程中不断询问第K小的整数是多少，怎么办？平衡树可以实现，但线段树显然是更好的方法。对每个结点，存储一个K0值表示位于该结点区间内的整数的个数，则查找第K小的时候只需要不断执行以下操作：Kth(A, K)，表示在结点A代表的区间内找第K小的，然后，若K<=结点A的左子结点K0值，则执行Kth(A的左子结点, K)，否则执行Kth(A的右子结点, K-A左子结点的K0)（这和平衡树神似），直到找到叶结点为止。这种方法称为“调整边界型”，即随着结点深入，不断缩小（自顶向下）或扩大（自底向上）范围，最后找到结果。像找第K小这样的操作属于自顶向下型，而像“找到X所在的具有某种性质的最长的连续区间”就属于自底向上型（注意和本题的Free不一样）；

（3）标记辅助型：
这种维护信息的方法，特点是利用标记来维护信息，即对于某些结点（主要是叶结点，因为其标记不再下放），直接使用标记来得到一些数据，比如对于HDU2871这一题，其中对于叶结点位于的插入线段的标号，使用的就是标记。

下面是本题4个操作的具体实现：
<1>线段树结点定义：
本题需要两棵线段树，这是因为New与Free操作对于tot域（插入线段左端点的总个数）会造成不同的影响，具体来说，在New操作中，tot值不会被同时加上（需要另外一个操作加上），然而在Free操作中，tot值会被同时清空，这样就会导致在对某个结点清空（该结点包含在某个Free操作要清空的线段中）并打上0标记之后，如果紧接着又插入一条包含这个结点区间的新线段，则这个结点的0标记就会丧失，这样在紧接着下传的时候，其子结点的tot值就不会被清空（事实上已经被清空了）。所以，将tot域彻底转移到另一棵线段树里。

struct node {
    int len, mr, lsc, rsc, sc;
} T[MAXN << 2];
struct node0 {
    int tot;
    bool mr;
} T0[MAXN << 2];

其中lsc、rsc、sc就是连续空闲段的长度（用左右归中的方法维护），mr是一个整体赋值标记，在T中，mr的值若为-1表示无标记（未被整体赋值），若为0表示被整体清空，若大于0表示整体被一条线段覆盖，mr值就是这条线段的编号（为区分不同线段，这里按照输入顺序对每一条New操作插入的线段以1、2……编号），在T0中，mr=1表示在Reset中被整体清空，mr=0表示无标记。
<2>操作处理：
1)Reset操作：将T、T0的根结点打上清空标记即可；
2)New：涉及到两个操作，分别是找最左的长度为x的连续空闲段，以及插入一条线段。对于前者，可以根据lsc、rsc、sc的值，按照“先左子结点，再跨越两个子结点，最后右子结点”的顺序求得（详见代码）；对于后者就不用说了，太容易实现了（注意标记的处理以及upd，另外要插入一个tot）；
3)Free：也涉及两个操作，分别是找一个点x所在的线段（插入过的线段）长度以及删除一条线段，对于前者可将New插入过的所有线段的左右端点预存起来，然后找到代表区间[x, x]的结点的mr值（也就是结点x被编号为神马的线段覆盖），再在预存的线段中找到即可。对于后者，直接清空即可（不要在T0中打标记，而要单独删除一个tot）；
4)Get：直接利用T0中的tot找到第K小的值即可；

代码

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

划分树

Mato_No1 — Mon, 27 Jun 2011 12:54:00 GMT

首先，Orz一下AHdoc神犇，本沙茶是看他的总结才搞懂划分树的。
原文地址

划分树，就是每个结点代表一个序列，设这个序列的长度为len，若len>1，则序列中前len/2（上取整，这里数学公式不好打，真囧）个元素被分到左子结点，左子结点代表的序列就是这些元素按照根结点中的顺序组成的序列，而剩下的元素被分到右子结点，右子结点代表的序列也就是剩下的元素按照根结点中的顺序组成的序列；若len=1，则该结点为叶结点。划分树最重要的应用就是找区间第K小（只是查找，不包括修改）。

写划分树时主要有两个函数：建树和找区间第K小。由于后者AHdoc神犇已经总结了，所以这里只总结建树的函数。

设目前结点为[l..r]（l>1。然后可以得到，[l..r]中小于中值的的元素一定被划分到左子结点，[l..r]中大于中值的元素一定被划分到右子结点，而[l..r]中等于中值的元素则不确定，有的被划分到左子结点，有的被划分到右子结点，这就需要先找到应被划分到左子结点的等于中值的元素个数sm（从mid开始不断往左，直到找到边界处或者找到一个小于中值的元素为止，或者说，sm就是a0[l..mid]中等于中值的元素个数），然后开始划分，小于中值分到左子结点，大于中值分到右子结点，等于中值的，若目前还没满sm则分到左子结点否则分到右子结点。另外中间有两个值需要记录（找区间第K小时必须要用到）：sl和sr。sl[i]表示[l..i]中被分到左子结点的元素个数，sr[i]表示[l..i]中被分到右子结点的元素个数（这里l<=i<=r。显然sl[i]+sr[i]=i-l+1，其实sr[i]可以不用记录的，这里只是为了在找第K小操作中减少计算次数，起到空间换时间的作用）。
建树代码：

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;
}

这里a是每层划分后的序列。
查找区间第K小的代码：

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++;
        }
    }
}

【具体题目】PKU2104、PKU2761（两道任选一道）

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

网络流图边表的新表示法：Dancing Link边表（解决需要删边或删点或改容量的多次求最大流问题）

Mato_No1 — Sat, 07 May 2011 06:12:00 GMT

考虑这样一种网络流问题：需要对同一个图求多次最大流。则在每次求最大流之前，需要将所有边的容量全部恢复到初始值（求最大流的过程中，边的容量f值被改变了）。不过这还不算最猥琐的，有的时候，我们需要在每次求最大流之前都删去图中的一些点或一些边，或者改变某些原有的边的容量，特别是需要删点或删边的情况爆难搞。因为，一般的边表中边类型定义如下：

struct edge {
int a, b, f, next;
} ed[MAXM + MAXM];

表示这条边起点为a，终点为b，容量为f，邻接边（就是下一条起点为a的边）的编号为next。
如果要求多次最大流，那么在每次求最大流之前就要把所有边的容量恢复到初始值，解决方法是引入一个“初始容量”域fs，在这条边刚刚被加入的时候将它的fs值和f值都设为初始给它的容量，在恢复时，只要将所有边的f值恢复到fs即可。若要改变边容量，则将该边的fs值和f值都设为改变后的容量即可。

下面来分析需要删边或删点的情况。在这种情况下，如果采用只有next的单向链表，则删除时next域极难处理，而且，在一般的边表中，还设立了表头hd，hd[a]表示边表中起点为a的第一条边的编号。因此，若删除的边是起点为a的第一条边，还会影响hd[a]的值，使情况变得更为复杂。因此，必须采用双向链表！还记得Dancing Link么？边表其实也可以搞成Dancing Link，方法如下：
设图中有N个点，M条边（注意，这M条边只包括正向边，不包括反向边。由于每条正向边都对应一条反向边，因此边表中边的数目其实是M+M）。首先把边表ed的0~N这(N+1)个位置（下标）空出来，作表头（表头不是边，因此在遍历边的时候不会遍历到它们）。其中，ed[0]为总表头，用于遍历ed[1..N]中每个未被删去的点；ed[1..N]为单点表头，ed[i]用来遍历图中所有以i为起点的边（和DLX中的二维DL惊人相似）。然后，若N为偶数，则空一个位置（也就是将ed[N+1]丢弃不用），这是因为我们在增广过程中需要引用到一条边对应的逆向边（正向边对应反向边，反向边对应正向边），一般认为编号为p的边对应的逆向边是p ^ 1，这样，就要求图中所有正向边的编号都是偶数，所有反向边的编号都是奇数（否则会造成混乱）。因此当N为偶数时，(N+1)为奇数，不能放置第一条正向边，需要从ed[N+2]开始放置正向边。若N为奇数则不用空位。
接下来就是边类型了。在这里，边类型一共需要包括6个域：a, b, fs, f, pre, next，表示这条边起点为a，终点为b，初始容量为fs，当前容量为f，上一条起点为a的边编号为pre，下一条起点为a的边编号为next。注意，和DL一样，整个链表是循环的，也就是我们认为表中最后一条起点为a的边的下一条邻接边编号就是a（表头），同样，a的上一条邻接边也就是这条边。

struct edge {
int a, b, fs, f, pre, next;
} ed[MAXM + MAXM];

接下来就是几个重要过程了。
（1）初始化表头：

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;
}

这里n是图中的点数（相当于N），m是边的编号指针（相当于DLX中的nodes）
（2）添加新边：

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++;
}

这个和DLX类似，不解释了囧……

最后进入最核心的部分——到底如何处理删边或删点？有了DL型边表就爆好搞了：删去一条边，只要直接删去该边在DL中的位置即可：

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;
}

需要删点的情况类似，对单点表头处理即可。

【具体题目】PKU1815
这题就是求有向图的字典序最小的最小点割集问题，方法是先求出最小点连通度（有关最小点连通度的求法见图的连通度问题的求法），然后按编号递增顺序枚举每个点，若删去该点（其实是删去建成的新图中该点i'到该点附加点i''之间的边）后图的最小点连通度减小，则应删去该点，否则不应删去该点。删去后，继续枚举下一个点，直到求出点割集为止。
注意，本题只有删边，没有删点，因此总表头可以不需要，直接从ed[0]开始作单点表头。此时，关于是否空位就刚好反过来了：如果N是奇数就要空位，N是偶数不空位（不过这题里由于建出的网络流图中有2*N0个结点，总是偶数，可以不管，不过本沙茶还是管这个了）。

代码（神犇不要鄙视）：

#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

【问题描述】
给出一个图G和指定的源点s、汇点t，求图中从点s到点t的第K短路。
【具体题目】PKU2449（注意：本题有一个猥琐之处：不允许空路径。也就是当s等于t时要将K值加1）
【算法】
本题有一种最朴素的办法：改造Dijkstra，一开始路径(s, 0)（这里设路径(i, l)表示从s到i的一条长度为l的路径）入队。然后，每次取队中长度最短的路径，该路径(i, l)出队，可以证明，若这是终点为i的路径第x次出队，该路径一定是图中从s到i的第x短路（若x>K则该路径已无用，舍弃）。然后从点i扩展，将扩展到的路径全部入队。这样直到终点为t的路径第K次出队即可。
该算法容易实现（借助priority_queue），但时间复杂度可能达到O(MK)，需要优化。
优化：容易发现该算法其实有A*的思想，或者说，该算法其实是所有结点的估价函数h()值均为0的A*算法。为了优化此题，需要将h()值改大。显然，h(i)值可以设为从i到t的最短路径长度（容易证明它是一致的），然后g(i)=目前结点代表的路径长度，f(i)=g(i)+h(i)，然后A*即可。

注意：更改路径条数应该在出队时更改，而不能在入队时更改，因为可能在该路径出队之前会有新的比它更短的路径入队。

代码（PKU2449）：

#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

摘要: 动态区间最大子序和问题【问题描述】给出一个序列A[0..N-1]和M个操作，每个操作都是以下三种之一：①：查询区间最大子序和操作格式：1 l r表示：查询A[l..r]内的最大子序和（就是A[l..r]内的和最大的连续子序列的和），0<=l<=r阅读全文

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

环形串的最优断点问题

Mato_No1 — Sat, 23 Apr 2011 08:09:00 GMT

【问题描述】
给出一个环形的字符串S，长度为N，现在要找到一个断开点，使得从这里断开后的字符串字典序最小。或者说，对于长度为N的字符串S[0..N-1]，找到一个位置i，使得字符串S' = S[i..N-1] + S[0..i-1]的字典序最小。若存在多个这样的最优断点，则取最左边(i最小)的那个。
【Sample Input】
amandamanda
【Sample Output】
10
（从第10位断开后得到的字符串"aamandamand"的字典序是11个断开位置中最小的）

【分析】
首先将这个环形串拆开：只需将S[0..N-1]的后面再接上S[0..N-2]即可（如对于样例，可构造字符串T = "amandamandaamandamand"），则T的任意一个长度为N的子串T[i..i-N+1]就是S从第i位断开得到的字符串。此时问题就变成了：给出一个长度为(2N-1)的字符串，求出其所有长度为N的子串中字典序最小的。

设F[x]为T中所有起始位小于N的长度为x的子串中字典序最小的子串的起始位（若有多个则取最左边的），如对于T="abaabaaababaabaaa"，有F[0]=F[1]=0，F[2]=2，F[3]=F[4]=5……本题的目的就是求出F[N]的值。一开始已知的只有F[0]=0（长度为0的字符串都是空串，字典序都是最小的，取最左边的第0位）。

可以发现，F数组有很多重要的性质：
性质1 F[0..N]数组是单调递增的。
证明：用反证法。设存在一个值x(0<=xF[x+1]则根据定义，有T[F[x+1]..F[x+1]+x]<=T[F[x]..F[x]+x]（这里一定不会越界，即F[x]+x的值一定不大于(2N-1)，因为xT[F[x]..F[x]+x-1]（否则F[x]的值就应该等于F[x+1]的值了），矛盾，故在F[0..N]中不可能存在任何F[x]>F[x+1]的情况，也即F[0..N]数组是单调递增的（以下将F[0..N]数组简称为F数组）。
性质2 对于任意值x(0<=xF[x]+x。
证明：因为前面已经证明了F数组是单调递增的，这里只需证明对于任意x(0<=x这里同样用反证法。设存在一个值x(0<=xF[x]+x。

根据F数组的以上两个性质可以设计出本题的算法：
设目前已经求出了F[0..x-1]的值，且F[x-1]=i。首先将T[0..i-1]全部删去（因为F数组是单调递增的，F[x]的值一定不小于i），然后对T自身作扩展KMP（就是以T为模板串，T为子串的扩展KMP，相当于其预处理部分），一开始先将F[x]置为i，设第j位的匹配长度为next[j]，若next[j]=x-1且T[j+x-1]
时间复杂度：O(NÖN)，可以根据性质2得到。

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

RMQ问题

Mato_No1 — Sat, 26 Mar 2011 02:13:00 GMT

今天终于搞懂了RMQ问题无比神犇的ST算法……

【离线RMQ问题】
题意：对于一个序列A[1..N]，共有M次提问，每次都是问A[l..r]（1<=l<=r<=N)中的最值，求出每次提问的答案。

（1）纯暴力枚举：O(NM)；
（2）树状数组：O(M(logN)^2)【见树状数组解决离线RMQ问题】
（3）ST算法：O(MlogN)……
ST算法是基于分块DP的。
设F[i][j]为A[i..(i+2^j-1)]（共2^j个元素）中的最值（前提是不能越界，即i+2^j-1 <= N），显然F可以通过DP的方式得到：
F[i][j] = min||max{F[i][j-1], F[i+2^(j-1)][j-1]}
边界：F[i][0]=A[i]。
DP求F的值的时间复杂度为O(NlogN)（一共只有NlogN个F值有意义）；

然后，对于求A[l..r]中的最值，只要将A[l..r]拆成若干连续的段，使得每段的长度都是2的整数次幂就行了，比如A[3..28]可以拆成A[3..18]、A[19..26]、A[27..28]三段，长度分别是16（2^4）、8（2^3）、2（2^1），所以min||max{A[3..28]} = min||max{F[3][4], F[19][3], F[27][1]}。
关键是怎么拆？方法：求出(r-l+1)（即A[l..r]的长度）的二进制形式，然后从高位到低位依次遍历，如果找到1位就加上目前的位对应的幂，如(28-3+1)=(11010)2，所以依次找到F[3][4]、F[3+2^4][3]、F[3+2^4+2^3][1]。注意此时需要预先设一个数组B，B[2^i]=i，以方便找到某个取出的幂对应的指数。
显然，最多只有logN段，所以一次提问的时间复杂度为O(logN)。

其实还有一种方法，就是先求出log(r-l+1)的值（下取整），设为x，然后F[l][x]和F[r-2^x+1][x]中的较大/较小值就是A[l..r]中的最值。这样，一次提问的时间复杂度就降到了O(1)。问题是，系统log函数灰常慢，也许算一次log函数值的时间已经超过了logN，这样显然得不偿失。所以仍然推荐上面的方法。

【核心代码（以求最小值为例，最大值类似）】
分段法：

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值法：

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数组值的预处理代码（注意，如果采用求log值的方法就不需要B数组了）：

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]);
    }
}

【后经效率测试，发现当N=M=100000的随机数据中，两种方法都可以在0.4s以内得出正确结果，其中log值法比分段法略慢0.01s左右，相差不大，但考虑到“尽量少使用数学函数”的原则，仍推荐分段法】

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