Hdu 6155 Subsequence Count 矩阵计算DP+线段树维护

Subsequence Count

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 256000/256000 K (Java/Others)
Total Submission(s): 782    Accepted Submission(s): 288

Problem Description

Given a binary string  S[1,...,N] (i.e. a sequence of 0's and 1's), and  Q queries on the string.

There are two types of queries:

1. Flipping the bits (i.e., changing all 1 to 0 and 0 to 1) between  l and  r (inclusive).
2. Counting the number of distinct subsequences in the substring  S[l,...,r].

 

Input

The first line contains an integer  T, denoting the number of the test cases.

For each test, the first line contains two integers  N and  Q.

The second line contains the string  S.

Then  Q lines follow, each with three integers  type,  l and  r, denoting the queries.

1≤T≤5

1≤N,Q≤105

S[i]∈{0,1},∀1≤i≤N

type∈{1,2}

1≤l≤r≤N

 

Output

For each query of type 2, output the answer mod ( 109+7) in one line.

 

Sample Input

2 4 4 1010 2 1 4 2 2 4 1 2 3 2 1 4 4 4 0000 1 1 2 1 2 3 1 3 4 2 1 4

 

Sample Output

11 6 8 10

 

Source

2017中国大学生程序设计竞赛 - 网络选拔赛

给一个01串，要求完成两种操作：

1.区间修改，把一段区间的数值取反

2.区间查询，查询某一段的不同的01串子序列数量

如果我们用dp[i][0]和dp[i][1]表示dp到第i位，以0、1结尾的不同的子序列数量，则很容易得到DP公式：

dp[i][0]=dp[i-1][0]+dp[i-1][1]+1,dp[i][1]=dp[i-1][1]      第i位为0

dp[i][1]=dp[i-1][0]+dp[i-1][1]+1,dp[i][0]=dp[i-1][0]      第i位为1

那么把dp[i][0],dp[i][1],1当做矩阵的一列，可以很容易地把DP过程表示成矩阵乘法的形式。

dp[i][0]            1 1 1        dp[i-1][0]

dp[i][1]     =     0 1 0   *   dp[i-1][1]

    1                 0 0 1               1     

或者

dp[i][0]            1 0 0        dp[i-1][0]

dp[i][1]     =     1 1 1   *   dp[i-1][1]

    1                 0 0 1               1     

每次DP相当于左乘一个转移矩阵，查询[l,r]的答案相当于dp的初始值左乘[l+1,r]的转移矩阵的乘积。

那么，我们可以用线段树维护转移矩阵，查询的时候查询转移矩阵就好了。

而修改时，反转一段相当于某一段区间异或1，我们可以用异或标记在线段树上标明。而此时的转移矩阵，恰好把第一列和第二列交换、第一行和第二行交换，就可以了。(草稿纸推理演算得到)

矩阵乘法的常数比较大，我们发现转移矩阵最后一行只能是0,0,1，可以由此优化一下，减少时间复杂度。

最后跑了2873ms

#include 
#include 
#include 
#define mem0(a) memset(a,0,sizeof(a))
#define meminf(a) memset(a,0x3f,sizeof(a))
#define size 3
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
const int maxn=100005,inf=0x3f3f3f3f;  
const ll llinf=0x3f3f3f3f3f3f3f3f,mod=1e9+7;   
char s[maxn];
int num;

struct Matrix {  
    ll a[size][size];  
};
Matrix m0=(Matrix){1,1,1,0,1,0,0,0,1};
Matrix m1=(Matrix){1,0,0,1,1,1,0,0,1};

void print(Matrix v) {
	int i,j;
	for (i=0;i=l&&tree[now].r<=r) {
		tree[now].isxor^=1;
		flip(tree[now].sum);
	} else {
		pushdown(now);
		if (l<=(tree[now].l+tree[now].r)/2) 
		    update(tree[now].lc,l,r);
		if (r>(tree[now].l+tree[now].r)/2)
		    update(tree[now].rc,l,r);
		tree[now].sum=tree[tree[now].rc].sum*tree[tree[now].lc].sum;
	}
}

Matrix findsum(int now,int l,int r) {
//	cout << now << ' ' << tree[now].l << ' ' << tree[now].r << ' ' << tree[now].tag << endl;
	if (tree[now].l>=l&&tree[now].r<=r) {
		return tree[now].sum;
	} else {
		pushdown(now);
		if (r>(tree[now].l+tree[now].r)/2) {
			Matrix f;
			f=findsum(tree[now].rc,l,r);
			if (l<=(tree[now].l+tree[now].r)/2) 
		        f=f*findsum(tree[now].lc,l,r);
		    return f;
		} else return findsum(tree[now].lc,l,r);
	}
}

bool findval(int now,int pos) {
//	cout << now << ' ' << tree[now].l << ' ' << tree[now].r << ' ' << tree[now].tag << endl;
	if (tree[now].l>=pos&&tree[now].r<=pos) {
		return tree[now].isxor^(s[pos]-'0');
	} else {
		pushdown(now);
		if (pos<=(tree[now].l+tree[now].r)/2) 
		    return findval(tree[now].lc,pos);
		if (pos>(tree[now].l+tree[now].r)/2) 
			return findval(tree[now].rc,pos);
	}
}

int main() {
	int cas;
	scanf("%d",&cas);
	while (cas--) {
		int n,m,i,j,l,r,t;
		scanf("%d%d",&n,&m);
		scanf("%s",s+1);
		num=1;
		build(1,1,n);
		for (i=1;i<=m;i++) {
			scanf("%d%d%d",&t,&l,&r);
			if (t==1) update(1,l,r); else {
				if (l==r) {
					printf("1\n");
					continue;
				}
				Matrix v,t;
				if (findval(1,l)) t=(Matrix){0,0,0,1,0,0,1,0,0};
	        	    else t=(Matrix){1,0,0,0,0,0,1,0,0};
	        	v=findsum(1,l+1,r);
	      //  	print(v);
	        	v=v*t;
	        	ll q=(v.a[0][0]+v.a[1][0])%mod;
	        	printf("%lld\n",q);
			}
		}
	}
	return 0;
}