CF1252K. Addition Robot-优快云博客

本文链接：https://blog.youkuaiyun.com/yaoct/article/details/104335882

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Adding two numbers several times is a time-consuming task, so you want to build a robot. The robot should have a string S=S1S2…SNS=S1S2…SN of NN characters on its memory that represents addition instructions. Each character of the string, SiSi, is either 'A' or 'B'.

You want to be able to give QQ commands to the robot, each command is either of the following types:

1 LL RR. The robot should toggle all the characters of SiSi where L≤i≤RL≤i≤R. Toggling a character means changing it to 'A' if it was previously 'B', or changing it to 'B' if it was previously 'A'.

2 LL RR AA BB. The robot should call f(L,R,A,B)f(L,R,A,B) and return two integers as defined in the following pseudocode:

    function f(L, R, A, B):
      FOR i from L to R
        if S[i] = 'A'
          A = A + B
        else
          B = A + B
      return (A, B)

You want to implement the robot's expected behavior.

Input

Input begins with a line containing two integers: NN QQ (1≤N,Q≤1000001≤N,Q≤100000) representing the number of characters in the robot's memory and the number of commands, respectively. The next line contains a string SS containing NN characters (each either 'A' or 'B') representing the initial string in the robot's memory. The next QQ lines each contains a command of the following types.

1 LL RR (1≤L≤R≤N1≤L≤R≤N)
2 LL RR AA BB (1≤L≤R≤N1≤L≤R≤N; 0≤A,B≤1090≤A,B≤109)

There is at least one command of the second type.

Output

For each command of the second type in the same order as input, output in a line two integers (separated by a single space), the value of AA and BB returned by f(L,R,A,B)f(L,R,A,B), respectively. As this output can be large, you need to modulo the output by 10000000071000000007.

Example

input

Copy

5 3
ABAAA
2 1 5 1 1
1 3 5
2 2 5 0 1000000000

output

Copy

11 3
0 1000000000

Note

Explanation for the sample input/output #1

For the first command, calling f(L,R,A,B)f(L,R,A,B) causes the following:

Initially, A=1A=1 and B=1B=1.
At the end of i=1i=1, A=2A=2 and B=1B=1.
At the end of i=2i=2, A=2A=2 and B=3B=3.
At the end of i=3i=3, A=5A=5 and B=3B=3.
At the end of i=4i=4, A=8A=8 and B=3B=3.
At the end of i=5i=5, A=11A=11 and B=3B=3.

Therefore, f(L,R,A,B)f(L,R,A,B) will return (11,3)(11,3).

For the second command, string SS will be updated to "ABBBB".

For the third command, the value of AA will always be 00 and the value of BB will always be 10000000001000000000. Therefore, f(L,R,A,B)f(L,R,A,B) will return (0,1000000000)(0,1000000000).

线段树里存矩阵!!,为了少new数组，矩阵相乘有时还要保留原矩阵！！不然java版的不能过！！

参考：https://blog.youkuaiyun.com/Endeavor_G/article/details/102785359

import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class Main {
	public static void main(String args[]) {new Main().run();}

	FastReader in = new FastReader();
	PrintWriter out = new PrintWriter(System.out);
	void run(){
		work();
		out.flush();
	}
	long mod=1000000007;
	long gcd(long a,long b) {
		return a==0?b:gcd(b%a,a);
	}
	/*  [1,0] [1,1]
		[1,1] [0,1]
	*/
	long[][][] A; 
	long[][][] B;
	long[] lazy;
	void work() {
		int n=ni(),p=ni();
		A=new long[n<<2][][];
		B=new long[n<<2][][];
		lazy=new long[n<<2];
		String str=ns();
		build(1,0,n-1,str);
		for(int i=0;i<p;i++) {
			int t=ni();
			if(t==1) {
				update(1,0,n-1,ni()-1,ni()-1);
			}else {
				long[][] R=query(1,0,n-1,ni()-1,ni()-1);
				long[][] C={{nl(),nl()}};//向量
				long[][] ret=mul(C,R,null);
				out.println(ret[0][0]+" "+ret[0][1]);
			}
		}
	}


	private long[][] query(int idx, int l, int r, int s, int e) {
		if(l>=s&&r<=e) {
			return A[idx];
		}
		updateLazy(idx);
		long[][] ret=null;
		int m=l+(r-l)/2;
		if(m>=s) {
			ret=query(idx<<1,l,m,s,e);
		}
		if(m+1<=e) {
			long[][] ret2=query(idx<<1|1,m+1,r,s,e);
			if(ret==null) {
				ret=ret2;
			}else {
				ret=mul(ret,ret2,null);
			}
		}
		return ret;
	}


	private void update(int idx, int l, int r, int s, int e) {
		if(l>=s&&r<=e) {
			swap(idx);
			lazy[idx]^=1;
		}else {
			updateLazy(idx);
			int m=l+(r-l)/2;
			if(m>=s) {
				update(idx<<1,l,m,s,e);
			}
			if(m+1<=e) {
				update(idx<<1|1,m+1,r,s,e);
			}
			A[idx]=mul(A[idx<<1],A[idx<<1|1],A[idx]);
			B[idx]=mul(B[idx<<1],B[idx<<1|1],B[idx]);
		}
	}


	private void updateLazy(int idx) {
		if(lazy[idx]==0)return;
		lazy[idx]=0;
		lazy[idx<<1]^=1;
		swap(idx<<1);
		lazy[idx<<1|1]^=1;
		swap(idx<<1|1);
	}


	private void swap(int idx) {
		long[][] temp=A[idx];
		A[idx]=B[idx];
		B[idx]=temp;
	}


	private void build(int idx, int l, int r, String str) {
		if(l==r) {
			if(str.charAt(l)=='A') {
				A[idx]=new long[][] {{1,0},{1,1}};
				B[idx]=new long[][] {{1,1},{0,1}};
			}else {
				A[idx]=new long[][] {{1,1},{0,1}};
				B[idx]=new long[][] {{1,0},{1,1}};
			}
		}else {
			int m=l+(r-l)/2;
			build(idx<<1,l,m,str);
			build(idx<<1|1,m+1,r,str);
			A[idx]=mul(A[idx<<1],A[idx<<1|1],A[idx]);
			B[idx]=mul(B[idx<<1],B[idx<<1|1],B[idx]);
		}
	}


	private long[][] mul(long[][] A, long[][] B, long[][] D) {//保留D矩阵，不然不能过！！
		int n=A.length,m=A[0].length,k=B[0].length;
		if(D==null) {
			D=new long[n][k];
		}
		for(int i=0;i<n;i++) {
			for(int j=0;j<k;j++) {
				D[i][j]=0;
				for(int l=0;l<m;l++) {
					D[i][j]+=A[i][l]*B[l][j];
					D[i][j]%=mod;
				}
			}
		}
		return D;
	}


	//input
	private ArrayList<Integer>[] ng(int n, int m) {
		ArrayList<Integer>[] graph=(ArrayList<Integer>[])new ArrayList[n];
		for(int i=0;i<n;i++) {
			graph[i]=new ArrayList<>();
		}
		for(int i=1;i<=m;i++) {
			int s=in.nextInt()-1,e=in.nextInt()-1;
			graph[s].add(e);
			graph[e].add(s);
		}
		return graph;
	}

	private ArrayList<long[]>[] ngw(int n, int m) {
		ArrayList<long[]>[] graph=(ArrayList<long[]>[])new ArrayList[n];
		for(int i=0;i<n;i++) {
			graph[i]=new ArrayList<>();
		}
		for(int i=1;i<=m;i++) {
			long s=in.nextLong()-1,e=in.nextLong()-1,w=in.nextLong();
			graph[(int)s].add(new long[] {e,w});
			graph[(int)e].add(new long[] {s,w});
		}
		return graph;
	}

	private int ni() {
		return in.nextInt();
	}

	private long nl() {
		return in.nextLong();
	}
	
	private String ns() {
		return in.next();
	}

	private long[] na(int n) {
		long[] A=new long[n];
		for(int i=0;i<n;i++) {
			A[i]=in.nextLong();
		}
		return A;
	}
	private int[] nia(int n) {
		int[] A=new int[n];
		for(int i=0;i<n;i++) {
			A[i]=in.nextInt();
		}
		return A;
	}
}	

class FastReader
{
	BufferedReader br;
	StringTokenizer st;

	public FastReader()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}


	public String next() 
	{
		while(st==null || !st.hasMoreElements())//回车，空行情况
		{
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

	public int nextInt() 
	{
		return Integer.parseInt(next());
	}

	public long nextLong()
	{
		return Long.parseLong(next());
	}
}