C++博客-Mato is No.1-随笔分类-动态规划

【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复仇】SCOI2008 着色方案

Mato_No1 — Wed, 24 Oct 2012 06:59:00 GMT

原题地址
首先，看这么小的范围就知道，数学方法肯定搞不了……又想不到其它模型……只能用状压硬搞了囧……
问题是，5^15稳T，如果能倒过来，15^5，就不会T了。
可以发现，C值相同的颜色本质上是一样的……因此，只需要保存目前C值为1、2、3、4、5的颜色各有多少种就行了囧……（当然在过程中还会出现C值为0的，即用完的颜色，不过0、1、2、3、4、5的和是颜色总数，而且从下面可以看出，C值为0的确实“木有用”）；
设F[s1][s2][s3][s4][s5][v]为涂完前若干个木块（这个个数可以通过s1~s5算出，不过我们并不需要它囧……）后，C值为1~5的颜色各有s1～s5种，且这若干个中的最后一个涂的颜色还剩的C值为v（显然0<=v<=4）。
边界：F[S[1]][S[2]][S[3]][S[4]][S[5]][0]=1，其余为0（S[i]为一开始C值为i的颜色种数）。
计算F时，前推后（注意顺序，是按照S[5]逆序最先，再依次是S[4]～S[1]，都是逆序，v可任意定序），枚举下一个木块的颜色是现在还剩多少的，如果它与目前的这个（最后一个）剩的相同，则要减1，否则不减。具体的方程见代码。
注意细节：枚举F的s1~s5下标时，都要N（颜色总数）开始枚举，因为过程中某些s值会增加；

本题的启示就是，在设计状压DP的时候，如果正着来不行，可以反着来，或许就能设计出符合要求的解法。

代码：

Mato_No1 2012-10-24 14:59 发表评论

【AHOI2013复仇】NOI2008 道路设计

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

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

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

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

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

代码：

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

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

【AHOI2013复仇】两道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 发表评论

炮兵阵地以及与其相关的一类状压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 发表评论

KMP、AC自动机在字符串匹配类动态规划问题中的应用

Mato_No1 — Sun, 30 Oct 2011 03:22:00 GMT

有一类动态规划（其中也包含递推）问题，要求满足一些限制条件的字符串，这些限制条件是“需要含有某个子串”或“不能含有某个子串”，那么KMP、AC自动机等就有大用了。

【例1】HDU3689
题意：字符集中有一些字符，给出每个字符的出现概率（它们的和保证为1），再给出一个子串B，求：任给一个长度为N的字符串A（只能包含字符集中的字符），使得S是A的子串的概率。

求解这类问题首先要进行补集转化。因为子串可能有重叠（比如"ababa"中就出现了两个"aba"），所以先转化为“求任给一个长度为N的字符串A（只能包含字符集中的字符），使得B不是A的子串的概率”，然后再用1减去这个概率即为结果。
设F[i][j]为“在所有长度为i的不出现B的字符串中，后缀与B的前缀匹配长度为j（即该字符串的后缀与B的前缀的最大匹配长度为j）的概率”，很显然，F是由递推得到了，关键是如何进行状态转移？或者说，在递推过程中，哪些状态可能成为F[i][j]的前趋状态？
假设F[i-1][k]是F[i][j]的前趋状态，也就是说，在字符集中至少存在一个字符c，使得主串的第i位（最后一位）取c时，能够从F[i-1][k]转移到F[i][j]。这就需要求一个值S[k][c]，表示当主串的后缀与B的前缀的（最大）匹配长度为k时，在主串后再加上一个字符c，其匹配长度会变成什么。举例：设目前主串A'="abasab"，B="asabs"，其匹配长度为4，若在A'后加上一个字符's'，则匹配长度变为5，所以S[4]['s']=5，而若在A'后加上一个字符'a'，则匹配长度会变成1，所以S[4]['a']=1。显然S值和A前面的哪些字符是没有关系的。
那么这个S值如何计算？其实可以发现，S和KMP算法中的nx数组神似，因此完全可以按照计算nx数组的办法来计算S。具体来说，先要对B作KMP自身匹配，求出其nx数组，然后，在求S[k][c]的时候，尝试在B的第k位（由于B的下标从0开始所以B[k-1]）后加上字符c，看看会“回退”到哪里即可。代码：

     int j = 0; nx[0] = 0;
     re2(i, 1, m) {
            while (j && A[i] != A[j]) j = nx[j - 1];
            if (A[i] == A[j]) j++;
            nx[i] = j;
     }
     re(i, m) re(k, SZ) {
           j = i;
           while (j && A[j] != k + 97) j = nx[j - 1];
           if (A[j] == k + 97) S[i][k] = ++j; else S[i][k] = 0;
     }

这里m是B的长度。注意，当i=m时，S[i][j]是无意义的，因为前面已经说过了不能出现B。
在求出S值后就能求出F值了。对于状态F[i][j]，若存在一个字符c使得x=S[i][c]（满足0<=x最终结果为1-∑F[N][0..m-1]。

代码

【例2】PKU1625（URAL1158）
题意：给出一些子串，求长度为N，各个字符都属于给定的字符集的所有字符串中，不包含任何一个给出的子串的字符串个数（需要使用压9位的高精度）。

本题显然是【例1】的多子串形式，而用来解决多个字符串同时匹配的只有AC自动机，那么如何在本题中使用AC自动机求解呢？
观察【例1】中的F[i][j]，可以想象一下，一个图中有m个顶点，分别表示匹配长度为0..(m-1)，然后不断新加入的字符让这些状态在这些结点间不断转移（状态转移就是图中的边），这样，F[i][j]就表示“阶段i到达结点j上”。而AC自动机是基于Trie（树）的，其中有现成的结点，这就揭示了本题的状态：
F[i][j]表示长度为i的合法的字符串（就是满足字符集限制且不包含任何一个给定子串）中，在匹配到最后一位（第i位）后，刚好到达结点j的字符串的个数。
同样，S[k][c]表示“目前到达结点k，接下来的一个字符是c的时候，会到达哪个结点。在对所有的子串建立了自动机之后，S值只要类似地搞就能求出来了。然后F的转移也就搞定了。
不过，本题要万分注意AC自动机的一个BUG：在建立了自动机以后，需要把所有本身不危险（如果一个结点代表的字符串刚好是某一个给出的不能出现的子串，则该结点是危险结点），但通过失败指针不断上溯能够到达一个危险结点的结点，也标记为危险结点，比如两个子串是"abcde"和"bc"，则代表"abcd"的那个结点由于包含了"bc"所以也是危险的。
此外，本题的输入要注意，字符集的ASCII码范围是-128~127，所以必须用char而不是unsigned char，且由于可能包含空格所以必须用gets()而不是scanf()输入，又因为C/C++中木有负数下标，因此在输入之后还要转化一下（加128）。

代码

【例3】PKU3691
题意：给出一些子串和一个字符串A（其每个字符均属于字符集{'A', 'C', 'G', 'T'}），求至少要改动A的几个字符（不能改成不属于字符集的字符），使得它不包含任何一个给出的子串，若不管怎么改都不行，则结果为-1。

这就是真正的DP了。设F[i][j]为前i位，到达的结点为j，最少改动的字符个数，则转移方程为
F[i][j] = min{F[i-1][x] + (A[i] != c)}，c∈{'A', 'C', 'G', 'T'}，S[x][c]=j。边界：F[0][root]=0，其余的F[0][]=+∞，A的实际下标从1开始。
求S数组的方法见【例2】

代码

【例4】PKU3208
题意：含有连续的三个数字6的正整数，称为"beastly number"，求第P个（1<=P<=50000000）"beastly number"（其位数不会超过15位）。
（这题是本沙茶在PKU上至今为止，自己想出算法的AC人数最少的题）
本题其实是用不着KMP的，因为"666"这样简单的子串……

思路：由于位数不会超过15位（后来发现最多只有10位），所以每个"beastly number"都可以看成一个长度为15，字符集为['0'..'9']的字符串（注意是可以有前导0的，因为位数可能不足15位）A，整个过程也就是从高位（第0位）向低位（第14位）求出A的各位。

预处理：求出F[i][j]，表示若A的前i位已经确定（其中不含"666"，准确来说是非末尾不含"666"），且前i位的末尾刚好有j个'6'（j的范围是0到3）时，有多少个"beastly number"（注意，前i位既然已经确定，就不可更改了，能够决定的只有第i位的后面）。
显然先要求出F0[i][j]表示有多少个不是"beastly number"。其递推方程不好写，见代码（其实也是很好理解的）。然后F[i][j]=10^14-i - F0[i][j]。

然后就是不断调整边界来构造了。准确来说，设前i-1位已经确定，现在要确定第i位，则枚举第i位是0~9中的哪个值，然后求出满足条件的最小的"beastly number"和最大的"beastly number"的名次（注意，名次是从1开始的），看看P在不在其中，这样就能确定了。严重注意：如果已确定的位数中已经出现了"666"，接下来的就不用枚举了，直接在后面接上P-L就行了，L为左边界。

但是，为什么要把本题放在KMP的专题里面呢囧？因为如果这个子串不是"666"而是一些结构复杂的东东比如"123131"这样的，只有借助KMP算法了。这时，F[i][j]就表示 A的前i位已经确定（非末尾不含这个子串），且其后缀与这个子串的前缀匹配长度为j，有多少个"beastly number" ，转移方程与前几个例子类似。

代码

总结：
KMP算法和AC自动机的状态转移性质决定了它们在字符串匹配类DP问题中的巨大作用。在实际应用中，要注意灵活使用它们。此外，AC自动机的那个BUG是一定要注意的。

Mato_No1 2011-10-30 11:22 发表评论

PKU3017

Mato_No1 — Fri, 08 Jul 2011 04:40:00 GMT

【原题见这里】

本沙茶见过的最猥琐的DP题啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊……

设F[i]为将A[1..i]拆分成若干段的最大值最小和，则有
F[i]=min{F[j] + max[j+1, i]}（B[i]<=j边界：F[0]=0。

下面是优化过程。JZP神犇的论文里面已经够详细了。这里只是简要说明一下。
首先容易证明，F是单调递增的。
然后一个很关键的定理是：若F[i]的最优决策为j，则有A[j]>∀A[k]（j
证明：用反证法。若A[j+1..i]中存在不小于A[j]的值，则可得max[j..i]=max[j+1..i]，又因为F单调递增，所以F[j-1]+max[j..i]<=F[j]+max[j+1.i]，即决策(j-1)一定不比决策j差，也就是决策j不可能成为最优决策。
这样，可以维护一个下标严格递增、A值严格递减的队列Q（即对于队列中的任意两个元素Q[i]和Q[j]，若iA[Q[j].pos]，具体实现时pos可省略）。则可能成为最优决策的决策要么是在这个队列Q里，要么是B[i]。对于队列中的某个决策Q[x]，该决策导出的值为F[Q[x]]+A[Q[x + 1]]（很容易证明max[Q[x]+1..i]=A[Q[x + 1]]），找到这些导出的值中的最小值即可（注意，队尾元素没有导出值）。对于决策B[i]，只需要在预处理的时候同时得到MAX[i]=max[B[i]+1..i]即可（也可以在O(N)时间内得到），决策B[i]导出的值为F[B[i]]+MAX[i]。
在删除队首过时元素的时候，需要把导出值也删除，删除队尾元素也一样，插入的时候，若插入前队列不为空，则需要插入一个导出值。也就是，需要一个支持在对数时间内进行插入、删除任意结点、找最小值等操作，显然用平衡树最好。

注意事项：
（1）不管是在队首删除还是在队尾删除，若删除的是队列中的最后一个元素，则不需要在平衡树中删除导出值；
（2）插入时，若插入前队列为空，则不需要在平衡树中插入导出值；
（3）在计算F[i]时，应先将决策i压入。

代码：
#include <iostream>
#include <stdio.h>
using namespace std;
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 100001;
struct node {
    int l, r, p, sz0, sz, mul;
    long long v;
} T[MAXN];
const long long INF = ~0Ull >> 2;
int n, N = 0, a[MAXN], b[MAXN], MAX[MAXN], Q[MAXN], front = 0, rear = -1, root = 0;
long long m, F[MAXN], res = 0;
void init()
{
    cin >> n >> m;
    re1(i, n) scanf("%d", &a[i]); a[0] = ~0U >> 2;
}
void prepare()
{
    re1(i, n) if (a[i] > m) {res = -1; return;}
    int x = 1;
    long long sum = 0;
    re1(i, n) {
        for (sum+=a[i]; sum>m; sum-=a[x++]) ;
        b[i] = x - 1;
    }
    re1(i, n) {
        for (; front<=rear && Q[front]<=b[i]; front++) ;
        for (; front<=rear && a[Q[rear]]<=a[i]; rear--) ;
        Q[++rear] = i; MAX[i] = a[Q[front]];
    }
}
void vst(int x)
{
    if (x) {
        cout << T[x].v << ' ';
        vst(T[x].l); vst(T[x].r);
    }
}
void slc(int _p, int _c)
{
    T[_p].l = _c; T[_c].p = _p;
}
void src(int _p, int _c)
{
    T[_p].r = _c; T[_c].p = _p;
}
void upd(int x)
{
    T[x].sz0 = T[T[x].l].sz0 + T[T[x].r].sz0 + T[x].mul;
    T[x].sz = T[T[x].l].sz + T[T[x].r].sz + 1;
}
void lrot(int x)
{
    int y = T[x].p;
    if (y == root) T[root = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    src(y, T[x].l); slc(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void rrot(int x)
{
    int y = T[x].p;
    if (y == root) T[root = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    slc(y, T[x].r); src(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void maintain(int x, bool ff)
{
    int z;
    if (ff) {
        if (T[T[T[x].r].r].sz > T[T[x].l].sz) {z = T[x].r; lrot(z);}
        else if (T[T[T[x].r].l].sz > T[T[x].l].sz) {z = T[T[x].r].l; rrot(z); lrot(z);} else return;
    } else {
        if (T[T[T[x].l].l].sz > T[T[x].r].sz) {z = T[x].l; rrot(z);}
        else if (T[T[T[x].l].r].sz > T[T[x].r].sz) {z = T[T[x].l].r; lrot(z); rrot(z);} else return;
    }
    maintain(T[z].l, 0); maintain(T[z].r, 1); maintain(z, 0); maintain(z, 1);
}
int find(long long _v)
{
    int i = root;
    long long v0;
    while (i) {
        v0 = T[i].v;
        if (_v == v0) return i; else if (_v < v0) i = T[i].l; else i = T[i].r;
    }
    return 0;
}
int Find_Kth(int K)
{
    int i = root, s0, m0;
    while (1) {
        s0 = T[T[i].l].sz0; m0 = T[i].mul;
        if (K <= s0) i = T[i].l; else if (K <= s0 + m0) return i; else {K -= s0 + m0; i = T[i].r;}
    }
}
void ins(long long _v)
{
    if (!root) {
        T[++N].v = _v; T[N].l = T[N].r = T[N].p = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; root = N;
    } else {
        int i = root, j;
        long long v0;
        while (1) {
            T[i].sz0++; v0 = T[i].v;
            if (_v == v0) {T[i].mul++; return;} else if (_v < v0) j = T[i].l; else j = T[i].r;
            if (j) i = j; else break;
        }
        T[++N].v = _v; T[N].l = T[N].r = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; if (_v < v0) slc(i, N); else src(i, N);
        while (i) {T[i].sz++; maintain(i, _v > T[i].v); i = T[i].p;}
    }
}
void del(int x)
{
    if (T[x].mul > 1) {
        T[x].mul--; while (x) {T[x].sz0--; x = T[x].p;}
    } else {
        int l = T[x].l, r = T[x].r, p;
        if (l && r) {
            int y; while (y = T[l].r) l = y;
            T[x].v = T[l].v; T[x].mul = T[l].mul; p = T[l].p;
            if (l == T[p].l) slc(p, T[l].l); else src(p, T[l].l);
            while (p) {upd(p); p = T[p].p;}
        } else {
            if (x == root) T[root = l + r].p = 0; else {p = T[x].p; if (x == T[p].l) slc(p, l + r); else src(p, l + r); while(p) {upd(p); p = T[p].p;}}
        }
    }
}
long long h(int x)
{
    return F[Q[x]] + a[Q[x + 1]];
}
void solve()
{
    F[0] = 0; front = 0; rear = 0; Q[0] = 0;
    re1(i, n) {
        for (; front<=rear && Q[front]<b[i];) {if (front < rear) del(find(h(front))); front++;}
        for (; front<=rear && a[Q[rear]]<=a[i];) {if (front < rear) del(find(h(rear - 1))); rear--;}
        Q[++rear] = i; if (front < rear) ins(h(rear - 1));
        if (root) F[i] = T[Find_Kth(1)].v; else F[i] = INF;
        if (F[b[i]] + MAX[i] < F[i]) F[i] = F[b[i]] + MAX[i];
    }
    res = F[n];
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    prepare();
    if (!res) solve();
    pri();
    return 0;
}

Mato_No1 2011-07-08 12:40 发表评论

多重背包问题的单调队列优化

Mato_No1 — Tue, 05 Jul 2011 10:00:00 GMT
多重背包问题朴素时间复杂度为O(NMS)（这里S是所有物品的数量s之和），经过二进制优化后时间复杂度为O(NMlog2S)，这个复杂度已经能够应付大多数题了，但对于某些特别卡时间的题（比如N*M=10⁷的)，仍然会TLE。这时，可以用单调队列优化，时间复杂度降为O(NM)。

首先看一下多重背包问题的朴素转移方程：
F[i][j] = max{F[i-1][j-x*w[i]]+x*v[i]} (0<=x<=s[i], j>=x*w[i])
如果使用滚动数组，忽略i这一维，设w0=w[i]，v0=v[i]，s0=s[i]，得：
F[j] = max{F[j-x*w0]+x*v0} (0<=x<=s0, j>=x*w0)
看上去这和单调队列木有神马关系，因为决策下标（j-x*w0）不是一个整数区间，中间是有间隔的。然而可以发现，这个方程的限制条件“0<=x<=s0，j>=x*w0”，也就是x的下界是max{0, j/w0（下取整）}，当j单调递增时，这个下界也是单调递增的。这满足单调队列优化的条件中的“决策下标的下界单调”……不是，还不能这样说，因为这里的决策下标是j-x*w0，而不是x。
那么怎样才可以把决策下标变为x？

将决策下标按照模w0的余数进行分类，可以分成w0类，分别对应模w0余0、余1……余(w0-1)的情况。这时，上面方程中的所有决策下标j-x*w0都是同一类的。进一步，设q =j/w0（下取整），r=j%w0，则j=q*w0+r，对于某个决策下标j'，设k=(j'-r)/w0，即j'=k*w0+r。显然可以发现，k的取值范围是：k>=0且q-s0<=k<=q，也即k的下界是max{0, q-s0}——随j的单调而单调。
然后，转移方程可以改为（这里把r当成一个已知量了）：
F[q*w0+r] = max{F[k*w0+r]+(q-k)*v0} (k>=0且q-s0<=k<=q)
即F[q*w0+r]=max{F[k*w0+r]-k*v0}+q*v0 (k>=0且q-s0<=k<=q)
设G[k]=F[k*w0+r]得：
G[q]=max{G[k]-k*v0}+q*v0 (k>=0且q-s0<=k<=q)
这个方程已经可以使用单调队列来优化了！

这样可以得出算法：
（1）从1到n，枚举i，建立w[i]个空的单调队列，每个队列的元素都是两个int值：(k, val)，表示转换后下标和决策值(G[k]-k*v[i])；
（2）从0到m，枚举j，得出q、r的值，对于队列r：
【1】删去队首过时（k【2】F[j]入队（这里的F[j]指上一阶段的F[j]，即F[i-1][j]。因此这一步操作一定要先进行），删去队尾所有决策值val不大于(F[j]-q*v[i])的元素。
【3】取出队首结点，其val值加上q*v[i]后即为本阶段F[j]的值。
最后F[m]即为结果。总时间复杂度为O(NM)。

其实这个是可以推广的，即对于如下形式的转移方程（其中H、G和W均为常量，B[i]为决策下标的下界，随i单调）：
F[i] = opt{F[i-x*H+W]}+G (B[i]<=i-x*H+WN）
都可以用上述的办法进行转化，从而进行单调队列优化。

Mato_No1 2011-07-05 18:00 发表评论