【算法学习笔记】40.树状数组 动态规划 SJTU OJ 1289 扑克牌分组

Description

cxt的扑克牌越来越先进了，这回牌面的点数还可以是负数， 这回cxt准备给扑克牌分组，他打算将所有的牌分成若干个堆,每堆的牌面总和和都要大于零。由于扑克牌是按顺序排列的,所以一堆牌在原牌堆里面必须是连续的。请帮助cxt计算一下,存在多少种不同的分牌的方案。由于答案可能很大,只要输出答案除以1,000,000,009的余数即可。

Input Format

第一行:单个整数:N,1 ≤ N ≤ 10^6

第二行到N + 1行:在第i + 1行有一个整数:Ai, 表示第i张牌牌面的值。

Output Format

第一行:单个整数,表示分组方案数除以1,000,000,009的余数

Sample Input

4
2
3
-3
1

Sample Output

4

hint

分别是[2 3 − 3 1], [2 3 − 3] [1], [2] [3 − 3 1], [2] [3 − 3] [1]

注意: 题目描述有误 不是正数 是非负数

1.纯dp O(n^2)

　　纯dp的方法很简单, dp[i]表示前i个数的分法. 状态转移方程为 dp[i] = sigma(dp[j])  j的条件是 0<= j < i  且 presum[j]<=presum[i]

后者保证了 [j+1,i] 这个段落的和大于等于0

　　PS: 一个错误的dp策略是 认为如果num[i]>=0 and num[i]+num[i-1] >=0 的话 就 dp[i] = 2*dp[i-1].  因为对于前i-1中分法的每一个分法的最后一个段落,可以认为num[i]放入还是不放入.这是错误的, 因为第i个数的加入 使得每一个分法的前面会重新组合.原本是负数的段落可能会变为正数

代码如下:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#define INF 1000000009
using namespace std;int* nums;
int* sums;
unsigned int* dp;int main(int argc, char const *argv[])
{int N; cin>>N;//动态数组nums = new int[N+5];sums = new int[N+5];dp =  new unsigned int[N+5];//输入初始化memset(sums,0,sizeof(int)*(N+5));for (int i = 1; i <= N; ++i){scanf("%d",&nums[i]);sums[i] = sums[i-1] + nums[i];}dp[0] = 1;for (int i = 1; i <= N; ++i){dp[i] = 0;for (int j = 0; j < i; ++j) if(sums[i]-sums[j]>=0)//表示从j+1到i 的和是整数可以成为一段
        {dp[i] += dp[j];dp[i] %= INF;// 容易写错
        }}cout<<dp[N] % INF <<endl;delete[] nums;delete[] sums;delete[] dp;return 0;
}

 

2.dp + 排序 去重 树状数组优化 O(nlgn)

　　O(n^2)会超时,最重要的原因是每个内层循环去寻找比presum[i]小的presum[j] 然后叠加dp[j]. 想优化这个过程 可以考虑先排序presum[],又因为相同的presum值,后来的presum对应的dp值可以根据之前的presum的dp值算出来,所以可以去重. 说的比较绕 举个例子把过程写出来也许会好一点

比如

5 

2 3 -5 2 1

nums: 2 3 -5 2 1

原始presum:2 5 0 2 3 

排序presum:0 2 2 3 5

去重uqsum:0 2 3 5 长度为4

树状数组c的下标从1开始一直到4 

假设有一个dp数组,这个数组dpk表示的与O(n^2)中的dp[k]不同,这里的dpk指的是

//以下用dpk表示这个算法里的dp; dp[k]表示上一个算法里的dp

　　　　令tmpSum = uqsum[k-1] "在uqsum里第k个(下标为k-1)的那个前缀和" 

　　　　当当前和是tmpSum时的总共的分法数目

比如dp1 表示的是 当前和为0时 分法有多少个 ; dp2 表示的是 当前和为2时 分法有多少个....

//注意 若有重复的当前和uqsum[k-1] dpk表示的是所有的累积 比如Step5的说明

根据树状数组的规则 把c数组和dp数组关联起来, 这样更新和查找都会变快

c1 = dp1

c2 = dp1+dp2

c3 = dp3

c4 = dp1+dp2+dp3+dp4

根据后继节点的定义: c1的后继是c2, c2的后继是c4,c3的后继是c4

根据前驱节点的定义: c3的前驱是c2 其他节点没有前驱节点

每次更新某一个树状数组的节点时,都要循环更新它的后继节点

每次获取某一个树状数组的节点开始的和时,要循环求出它的前驱节点的和 (从后面的例子中能体会到)

以上关于树状数组的理解来源于:http://www.cnblogs.com/xudong-bupt/p/3484080.html

----------------------------------------- 

#####

Step1:设置所有的 负前缀和 和 0前缀和 的dp值为1 ,这个例子中没有负前缀和

此步之前

dp : 0 0 0 0

此步之后

dp:  1 0 0 0 

相应的

c: 1 1 0 1 // 所以我们只要更新c1+1即可后继节点会跟着更新 update(c1,1)

#####

Step2: 获得第一个当前和 curSum = 0 +  num[1] = 2 //因为此时的presum已经排序了不能用,必须重新构造原始的前缀和

去uqsum数组里找比2小的有几个,发现有1个,它对应的分法数为dp1 之前curSum=2 和 分法的数目的和 对应的是dp2 (比较绕,往后看会好一点)

(这里就是之前提到的,为什么可以去重的原因,因为每次更新都是在前一阶段的同一位置 += )

所以 dp2 +=  (dp1 + dp2)

此时dp是

dp:  1 1 0 0

相应的树状数组的操作就是: update(2,getSum(c2)) 让c2和c2的后继节点都加上上一阶段的c2,所以此后

c2 += c2 ; c4+=c2;

c: 1 2 0 2

#####

Step3: 加入第二个数 curSum = 0 +  num[1] + num[2] = 5

在uqsum找到 有3个比5小的,他们分别对应 dp1,dp2,dp3 5对应的是dp4

所以 dp4 +=( dp1 + dp2 + dp3 + dp4 )

此时dp: 1 1 0 2

相应的树状数组操作就是: update(4,getSum(4))

c4 += c4

所以c: 1 2 0 4

#####

Step4: 加入第三个数 curSum = 0 + n1+n2+n3 = 0

在uqsum里找到0个比0小的, 所以只要让dp1 += (dp1)即可

()里面的dp1指的是上一次当前和是0的时候的分法数 

dp为: 2 1 0 2 //注意第一个2的含义 是 第一次当前和为0是的dp[0]=1,加上第二次为0的dp[3] = 1

相应的 update(1,getSum(1))

c1 += c1

c为: 2 3 0 5

#####

Step5: 加入第四个数 curSum = 0 + n1+n2+n3+n4 = 2

此时再去uq里面找比2小的 发现有1个 对应dp1 自己是dp2

此时还未更新的dp2指的是上一次Step2中的dp2, 所以 dp2 += (dp1+dp2)

这时很好说明Step4里: dp1=2的作用 因为它记录了两次当前和为0的累积情况所以 +dp1的时候有两个效果

第一个效果是  从num[1]到num[4]这个整体作为一种分法 因为dp[0]=0

第二个效果是  从num[4]到num[4]这一个数作为一段,之前的作为一段的分法 因为dp[3]=0

此时dp为: 2 4 0 2

说回来,对应的树状数组的操作就是

c2 += c2; c4+=c2;

update(2,getSum(2))

此时c为: 2 6 0 8

#####

Step6: 加入最后一个数 curSum = 0 +n1+n2+n3+n4+n5 = 3

去uqsum中找到比3小的有2个 分别对应 dp1 dp2 加上上一阶段的 dp3

所以结果其实就是res = dp1+dp2+dp3 此时输出结果 退出即可.

树状数组的取值是 res = getSum(3);

虽然c3 = dp3 但是因为c3 是有前驱节点c2的

所以getSum(3) =  c3 +c2 = dp3 + (dp1 + dp2) = 0 + 6

 

最终结果为6

------------------------------------

总结一下dp的变化过程

0 2 3 5 : 这个是uqsum

--------

0 0 0 0

1 0 0 0

1 1 0 0

1 1 0 2

2 1 0 2

2 4 0 2

最终输出 2+4+0

 

总结一下c的变化过程

0 2 3 5: 这个是uqsum

----------

0 0 0 0   

1 1 0 1  

1 2 0 2

1 2 0 4

2 3 0 5

2 6 0 8

最终输出 6+0

 

速度变快的原因是 c的加法操作数量比dp的加法操作数量少很多

代码如下:

#include <iostream>
#include <algorithm>
using namespace std;
int nums[100005]    ={0};//存储原始数据
int presum[100005]    ={0};//前缀和 后来排序
int uqsum[100005]    ={0};//排序且去重的前缀和
int cnt             = 0; //表示uq的长度
int c[100005]        ={0};//树状数组 存储dp
const int MOD = 1000000009;inline int lowbit(int cid){return cid & (-cid);
}inline int getSum(int cid){ //得到树状数组中id是cid的那个节点的值 int sum = 0;for (int i = cid; i >= 1 ; i -= lowbit(i)) //注意i的更新是找前驱节点sum = (sum + c[i]) % MOD;return sum;
}inline void update(int cid, int value){ //更新某一个c[cid]的值 value也是从c里取出来的 所以已经是几个dp的和了for (int i = cid; i <= cnt; i += lowbit(i))c[i] = (c[i] + value) % MOD;
}inline int find(int key){ //find(key)+1 表示的是 再uqsum中比key小的个数+1 正好是c中对应的cidreturn lower_bound(uqsum,uqsum+cnt,key) - uqsum; //lower_bound返回的是uqsum中小于cnt的最后一个的指针
}int main(int argc, char const *argv[])
{//输入数据 并且同时计算原始前缀和数组int N; cin>>N;presum[0]=0;for (int i = 1; i <= N; ++i){cin>>nums[i];presum[i] = presum[i-1] + nums[i];}//对presum排序 注意presum的长度为N+1sort(presum,presum+N+1);//去重 加入到uqsum中 
    uqsum[cnt] = presum[0];//因为presum[0]可能是负数for (int i = 1; i < N+1; ++i){if(presum[i] != uqsum[cnt])uqsum[++cnt] = presum[i];}cnt++;//cnt表示个数//初始化c数组 update(find(0)+1,1);// 如果前缀和没有负数: 其实是dp1=1的意思 指的是前缀和为uqsum[0]的分法为1// 如果前缀和里有负数: 就是 dp1 = dp2...= dpk = 1 其中uqsum[k-1] = 0int res = 0; //记录每次的dp和, 用于更新下一阶段int curSum = 0;for (int i = 1; i <= N; ++i)//针对每个前缀和
    {curSum +=  nums[i];int cid = find(curSum) + 1; //得到当前和对应的cidres = getSum(cid);            //
        update(cid,res);            //
        }return 0;
}