hdu-5694 BD String(分治)

题目链接：

BD String

Time Limit: 2000/1000 MS (Java/Others)   

 Memory Limit: 65536/65536 K (Java/Others)

Problem Description

 

众所周知，度度熊喜欢的字符只有两个：B和D。

今天，它发明了一种用B和D组成字符串的规则：

S(1)=B

S(2)=BBD

S(3)=BBDBBDD

…

S(n)=S(n−1)+B+reverse(flip(S(n−1))

其中，reverse(s)指将字符串翻转，比如reverse(BBD)=DBB，flip(s)指将字符串中的B替换为D，D替换为B，比如flip(BBD)=DDB。

虽然度度熊平常只用它的电脑玩连连看，这丝毫不妨碍这台机器无与伦比的运算速度，目前它已经算出了S(21000)的内容，但度度熊毕竟只是只熊，一次读不完这么长的字符串。它现在想知道，这个字符串的第L位（从1开始）到第R位，含有的B的个数是多少？

 

Input

 

第一行一个整数T，表示T(1≤T≤1000) 组数据。

每组数据包含两个数L和R(1≤L≤R≤10^18) 。

 

Output

 

对于每组数据，输出S(21000)表示的字符串的第L位到第R位中B的个数。

 

Sample Input

 

3

1 3

1 7

4 8

 

Sample Output

 

2

4

3

 

题意：

 

 

思路：

 

L[i],R[i]分别表示node==i时这个串的左右端点,dp[i][0]表示node==i时B的个数,dp[i][1]表示D的个数;

给一个区间[l,r]进行分治,mid=(L[i]+R[i])/2,如果r<mid容易想,当l>mid时这时就可以把求node==i-1时的[l,r]的B的

个数转化成求node==i-1时的[l',r']的D的个数,在转化成求r'-l'-[l',r']里面的B的个数,递归就可以了,

当l<mid<r的时候就是把前面两个整合一下,详细看代码ba ;

 

 

AC代码：

 

#include <bits/stdc++.h>
/*
#include <iostream>
#include <queue>
#include <cmath>
#include <map>
#include <cstring>
#include <algorithm>
#include <cstdio>
*/
using namespace std;
#define Riep(n) for(int i=1;i<=n;i++)
#define Riop(n) for(int i=0;i<n;i++)
#define Rjep(n) for(int j=1;j<=n;j++)
#define Rjop(n) for(int j=0;j<n;j++)
#define mst(ss,b) memset(ss,b,sizeof(ss));
typedef long long LL;
const LL mod=1e9+;
const double PI=acos(-1.0);
const int inf=0x3f3f3f3f;
const int N=1e5+;
int n;
LL L[],R[],dp[][];
int fun()
{
    L[]=;
    R[]=;
    dp[][]=;
    dp[][]=;
    for(int i=;i<=;i++)
    {
        L[i]=;
        R[i]=*R[i-]+;
        dp[i][]=dp[i-][]++dp[i-][];
        dp[i][]=dp[i-][]+dp[i-][];
    }
}
LL dfs(LL l, LL r,int node)
{
    if(l>r||node<)return ;
    if(l==L[node]&&r==R[node])return dp[node][];
    LL mid=(L[node]+R[node])>>;
    if(r<=mid)
    {
        if(r==mid)return +dfs(l,r-,node-);
        else return dfs(l,r,node-);
    }
    else
    {
        if(l>=mid)
        {
            if(l==mid)return r-l+-dfs(R[node]-r+,R[node]-l,node-);
            else return r-l+-dfs(R[node]-r+,R[node]-l+,node-);
        }
        else return dfs(l,mid-,node-)++r-mid-dfs(R[node]-r+,R[node]-mid,node-);
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    fun();
    while(t--)
    {
        LL l,r;
        scanf("%I64d%I64d",&l,&r);
        LL ans=dfs(l,r,);
        printf("%I64d\n",ans);
    }
    return ;
}