ZOJ 3911 Prime Query



---

Time Limit: 1 Second      Memory Limit: 196608 KB

---

You are given a simple task. Given a sequence A[i] with N numbers. You have to perform Q operations on the given sequence.

Here are the operations:

• A v l, add the value v to element with index l.(1<=V<=1000)
• R a l r, replace all the elements of sequence with index i(l<=i<= r) with a(1<=a<=10^6) .
• Q l r, print the number of elements with index i(l<=i<=r) and A[i] is a prime number

Note that no number in sequence ever will exceed 10^7.

Input

The first line is a signer integer T which is the number of test cases.

For each test case, The first line contains two numbers N and Q (1 <= N, Q <= 100000) - the number of elements in sequence and the number of queries.

The second line contains N numbers - the elements of the sequence.

In next Q lines, each line contains an operation to be performed on the sequence.

Output

For each test case and each query,print the answer in one line.

Sample Input

1
5 10
1 2 3 4 5
A 3 1      
Q 1 3
R 5 2 4
A 1 1
Q 1 1
Q 1 2
Q 1 4
A 3 5
Q 5 5
Q 1 5

Sample Output

2
1
2
4
0
4

segment error 就不能理解了

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAX = 10000000;
struct node
{
    int l,r;
    int lazytag;
    int num;
};
node tree[MAX];
int a[MAX],n,q;
int is_prime(int x)
{
    if(x == 1 || x == 0)
        return 0;
    int flag = 0;
    for(int i=2;i*i<= x;i++)
        if(x%i == 0)
        {
            flag = 1;
            break;
        }
    if(flag)
        return 0;
    else
        return 1;
}
void build_tree(int left,int right,int k)
{
    tree[k].l = left;
    tree[k].r = right;
    tree[k].lazytag = -1;
    if(left == right)
    {
        if(is_prime(a[left]))
            tree[k].num = 1;
        else
            tree[k].num = 0;
        return ;
    }
    else
    {
        int mid = (left + right)/2;
        build_tree(left,mid,k*2);
        build_tree(mid+1,right,k*2+1);
    }
    tree[k].num = tree[2*k].num + tree[k*2+1].num;
}
void add(int id,int v,int k)
{
    if(tree[k].l == id && tree[k].r == id)
    {
        a[id] = a[id] + v;
        if(is_prime(a[id]))
            tree[k].num = 1;
        else
            tree[k].num = 0;
        return ;
    }
    else
    {
        if(tree[k].lazytag != -1)
        {
            tree[2*k].lazytag = tree[2*k+1].lazytag = tree[k].lazytag;
            if(is_prime(tree[k].lazytag))
            {
                tree[2*k].num = tree[2*k].r - tree[2*k].l + 1;
                tree[2*k+1].num = tree[2*k+1].r - tree[2*k+1].l + 1;
            }
            else
            {
                tree[2*k].num = tree[2*k+1].num =0;
            }
            tree[k].lazytag = -1;
        }
        int mid = (tree[k].l + tree[k].r)/2;
        if(id <= mid)
            add(id,v,k*2);
        else
            add(id,v,k*2+1);
    }
    tree[k].num = tree[2*k].num + tree[2*k+1].num;
}
void change (int left,int right,int v,int k)
{
    if(tree[k].l == left && tree[k].r == right)
    {
        if(is_prime(v))
            tree[k].num = tree[k].r - tree[k].l +1;
        else
            tree[k].num = 0;
        tree[k].lazytag = v;
        return ;
    }
    else
    {
        if(tree[k].lazytag != -1)
        {
            tree[2*k].lazytag = tree[2*k+1].lazytag = tree[k].lazytag;
            if(is_prime(tree[k].lazytag))
            {
                tree[2*k].num = tree[2*k].r - tree[2*k].l + 1;
                tree[2*k+1].num = tree[2*k+1].r - tree[2*k+1].l + 1;
            }
            else
            {
                tree[2*k].num = tree[2*k+1].num =0;
            }
            tree[k].lazytag = -1;
        }
        int mid = (tree[k].r + tree[k].l)/2;
        if(right <= mid)
            change(left,right,v,k*2);
        else if(left > mid)
            change(left,right,v,2*k+1);
        else
        {
            change(left,mid,v,2*k);
            change(mid+1,right,v,2*k+1);
        }
        tree[k].num = tree[k*2].num + tree[k*2+1].num;
    }
}
int Search(int left,int right,int k)
{
    if(tree[k].l == left && tree[k].r == right)
    {
        return tree[k].num;
    }
    else
    {
        if(tree[k].lazytag != -1)
        {
            tree[k*2].lazytag = tree[k*2+1].lazytag = tree[k].lazytag;
            if(is_prime(tree[k].lazytag))
            {
                tree[2*k].num = tree[2*k].r - tree[2*k].l + 1;
                tree[2*k+1].num = tree[2*k+1].r - tree[2*k+1].l + 1;
            }
            else
            {
                tree[2*k].num = tree[2*k+1].num =0;
            }
            tree[k].lazytag = -1;
        }
        int mid = (tree[k].l + tree[k].r)/2;
        if(right <=mid)
            Search(left,right,k*2);
        else if(left > mid)
            Search(left,right,k*2+1);
        else
        {
            return (Search(left,mid,k*2)+Search(mid+1,right,k*2+1));
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        getchar();
        build_tree(1,n,1);
        /*
        for(int k=1;k<=10;k++)
            printf("%d %d %d %d\n",tree[k].l,tree[k].r,tree[k].num,tree[k].lazytag);
        */
        char order;
        int l,r,v;
        while(q--)
        {
            scanf("%c",&order);
            if(order == 'A')
            {
                scanf("%d%d", &v,&l);
                getchar();
                add(l,v,1);
            }
            else if(order == 'R')
            {
                scanf("%d%d%d", &v,&l,&r);
                getchar();
                for(int i=l;i<=r;i++)
                    a[i] = v;
                change(l,r,v,1);

            }
            else if(order == 'Q')
            {
                scanf("%d%d", &l,&r);
                getchar();
                int ans = Search(l,r,1);
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}