C++博客-Mato is No.1-随笔分类-树状数组

AHOI2006 基因匹配(match)

Mato_No1 — Sat, 19 Mar 2011 14:38:00 GMT

依照CLJ神犇的指示，最近本沙茶决定开始被数据结构题虐……先找来了省内的一道题（就是这道囧）……

题目大意：求两个长度为5N的序列的最长公共子序列长度，在两个序列中，整数1~N分别都出现5次。1<=N<=20000。

【注：本沙茶一开始用线段树的，后来在看了CLJ神犇的标程（Orz！！）之后终于明白了树状数组解法囧……】

LCS问题的朴素时间复杂度为O(NM)。对于本题显然需要优化。
观察LCS的转移方程：
F[i][j] = F[i-1][j-1]+1（当A[i]==B[j]时）
F[i][j] = max{F[i-1][j], F[i][j-1]}（当A[i]!=B[j]时）

可以将F用滚动数组来表示，即设F'为上阶段的F（即F[i-1]），则本阶段的F（即F[i]）可以由F'求得：
F[j] = F'[j-1]+1（当A[i]==B[j]时）
F[j] = max{F'[j], F[j-1]}（当A[i]!=B[j]时）

进一步，这个F'其实都不用记录，只需在每一阶段更新一遍F即可：
F[j] = F[j-1]+1（当A[i]==B[j]时）
F[j] = max{F[j], F[j-1]}（当A[i]!=B[j]时）
不过需要逆序更新（保证F[j-1]是上一阶段的而不是本阶段的），这与01背包有点像。

由题意可以发现，A[i]==B[j]的出现次数极少，在每阶段中只会出现5次！我们可以预先求出这5个地方的值，然后对于其它的F[j]，其在本阶段的值其实就是它前面的最大值（max{F[1..j-1]}），又因为我们最后只需知道F[N']（N'=5N，即序列长度）即可，故可设计出以下算法：
一开始F[1..N]均为0，然后将以下内容执行N'次，第i次：
（1）求出B序列中与A[i]相等的5个元素的位置，设为S[1..5]；
（2）依次更新F[S[5..1]]，每个都更新为它前面的最大值加1（很容易知道为神马），其它的值暂时不管；

N'次执行完后，整个序列中的最大值就是F[N']的值。由于这个算法中出现的主要操作是改动一个指定位置元素的值和找一个前缀区间中的最大值，因此可以采用树状数组，时间复杂度O(NlogN）（线段树必TLE）。

【总结：在本题中使用了一种“推迟更新”的方法，即需要更新一个值时，先暂时不理它，等到需要引用到它的时候再更新。这种方法最常见的应用就是线段树的结点标记。不过要注意的是，如果该值的推迟更新会对它后面要更新的值带来问题（也就是，这些后更新的值需要引用该值的新值），就不能使用这种方法。在本题中，其它位置的值的改变只与这5个特殊的位置有关，与其它因素无关，故可以使用这种方法。】

Mato_No1 2011-03-19 22:38 发表评论

树状数组解决离线RMQ问题

Mato_No1 — Sat, 19 Mar 2011 13:59:00 GMT

树状数组与线段树不同，它只能直接支持前缀区间（[1..r]）或后缀区间（[l..N]）上的操作，而对于一般区间（[l..r]）上的操作则需要通过两步操作间接完成：先对[1..r]进行操作再对[1..l-1]进行反操作（如加c的反操作就是减c），对于加法操作这样可反的操作是可以，而对于求最值这样的不可反的操作（无法通过[1..r]的最值与[1..l-1]的最值得出[l..r]的最值），就没有办法了。其实，用树状数组是可以解决离线RMQ问题的，但时间复杂度不太理想（一次操作的理论时间复杂度达O((logN)^2)）。

方法是（这里C[i]表示i管辖的数组结点中的最值）：设r'为目前的右端点，一开始r'=r。每次找到r'管辖的数组结点中最左边的那个的下标（即r' - (r' & (-r')) + 1），设为x。若x>=l，则将C[r']与目前的最值比较、更新，再将r'设为(x-1)；若x
本算法编程复杂度极低，但由于时间效率较低，难以适应较大范围数据（N, M>100000基本上就TLE了）

Mato_No1 2011-03-19 21:59 发表评论

树状数组求区间和的一些常见模型

Mato_No1 — Sat, 19 Mar 2011 11:53:00 GMT

树状数组在区间求和问题上有大用，其三种复杂度都比线段树要低很多……有关区间求和的问题主要有以下三个模型（以下设A[1..N]为一个长为N的序列，初始值为全0）：

（1）“改点求段”型，即对于序列A有以下操作：

【1】修改操作：将A[x]的值加上c；

【2】求和操作：求此时A[l..r]的和。

这是最容易的模型，不需要任何辅助数组。树状数组中从x开始不断减lowbit(x)（即x&(-x)）可以得到整个[1..x]的和，而从x开始不断加lowbit(x)则可以得到x的所有前趋。代码：

void ADD(int x, int c)
{
     for (int i=x; i<=n; i+=i&(-i)) a[i] += c;
}
int SUM(int x)
{
    int s = 0;
    for (int i=x; i>0; i-=i&(-i)) s += a[i];
    return s;
}

操作【1】：ADD(x, c);

操作【2】：SUM(r)-SUM(l-1)。

（2）“改段求点”型，即对于序列A有以下操作：

【1】修改操作：将A[l..r]之间的全部元素值加上c；

【2】求和操作：求此时A[x]的值。

这个模型中需要设置一个辅助数组B：B[i]表示A[1..i]到目前为止共被整体加了多少（或者可以说成，到目前为止的所有ADD(i, c)操作中c的总和）。

则可以发现，对于之前的所有ADD(x, c)操作，当且仅当x>=i时，该操作会对A[i]的值造成影响（将A[i]加上c），又由于初始A[i]=0，所以有A[i] = B[i..N]之和！而ADD(i, c)（将A[1..i]整体加上c），将B[i]加上c即可——只要对B数组进行操作就行了。

这样就把该模型转化成了“改点求段”型，只是有一点不同的是，SUM(x)不是求B[1..x]的和而是求B[x..N]的和，此时只需把ADD和SUM中的增减次序对调即可（模型1中是ADD加SUM减，这里是ADD减SUM加）。代码：

void ADD(int x, int c)
{
     for (int i=x; i>0; i-=i&(-i)) b[i] += c;
}
int SUM(int x)
{
    int s = 0;
    for (int i=x; i<=n; i+=i&(-i)) s += b[i];
    return s;
}

操作【1】：ADD(l-1, -c); ADD(r, c);

操作【2】：SUM(x)。

（3）“改段求段”型，即对于序列A有以下操作：

【1】修改操作：将A[l..r]之间的全部元素值加上c；

【2】求和操作：求此时A[l..r]的和。

这是最复杂的模型，需要两个辅助数组：B[i]表示A[1..i]到目前为止共被整体加了多少（和模型2中的一样），C[i]表示A[1..i]到目前为止共被整体加了多少的总和（或者说，C[i]=B[i]*i）。

对于ADD(x, c)，只要将B[x]加上c，同时C[x]加上c*x即可（根据C[x]和B[x]间的关系可得）；

而ADD(x, c)操作是这样影响A[1..i]的和的：若x=i）会将A[1..i]的和加上i*c。也就是，A[1..i]之和 = B[i..N]之和 * i + C[1..i-1]之和。
这样对于B和C两个数组而言就变成了“改点求段”（不过B是求后缀和而C是求前缀和）。
另外，该模型中需要特别注意越界问题，即x=0时不能执行SUM_B操作和ADD_C操作！代码：

void ADD_B(int x, int c)
{
     for (int i=x; i>0; i-=i&(-i)) B[i] += c;
}
void ADD_C(int x, int c)
{
     for (int i=x; i<=n; i+=i&(-i)) C[i] += x * c;
}
int SUM_B(int x)
{
    int s = 0;
    for (int i=x; i<=n; i+=i&(-i)) s += B[i];
    return s;
}
int SUM_C(int x)
{
    int s = 0;
    for (int i=x; i>0; i-=i&(-i)) s += C[i];
    return s;
}
inline int SUM(int x)
{
    if (x) return SUM_B(x) * x + SUM_C(x - 1); else return 0;
}

操作【1】：
ADD_B(r, c); ADD_C(r, c);
if (l > 1) {ADD_B(l - 1, -c); ADD_C(l - 1, -c);}

操作【2】：SUM(r) - SUM(l - 1)。

Mato_No1 2011-03-19 19:53 发表评论