CodeChef

题目链接：https://vjudge.net/problem/CodeChef-ANDMIN

Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.

You are given an array of N integers. You should support the following queries on this array.

• 0 L R : Find the minimum integer in the range A_L, A_L+1, ..., A_R.
• 1 L R X : You should apply the assignment A[i] = A[i] & X, for all indices i in range [L, R], where & denotes bitwise AND operation.

 

Input

First line of the input contains two space separated integers N and Q.

Second line contains N integer numbers denoting array A.

In the next Q lines, each contain one of the queries described above.

Output

For each query of the type 0, output a single line containing the answer of the query.

Constraints

• 1 ≤ N, Q ≤ 10⁵
• 1 ≤ A_i, X ≤ 10⁹
• 1 ≤ L ≤ R ≤ N

Example

Input:
5 5
1 5 2 3 4
0 2 5
1 1 5 6
0 2 2
1 2 5 3
0 1 3

Output:
2
4
0

题意：

给出一个序列。有两种操作：0 L R，查询区间 [L, R]的最小值，1 L R X，对区间[L,R]中的每个数与x作与操作。

题解：

1.线段树的应用。可知对于一个int类型的值，最少只需做31次与操作，每一位上的值都全部为0。

2.构架线段树，线段树中的每个结点，除了记录当前段的最小值之外，还需记录一个状态，这个状态即：这一段中，有哪些位是为1的。当此段的这个位为1，且x的这个位为0，那么就可以继续往下更新，把这个段中的这个位置为0；否则，当此段的这个位为0，而x的这个位为0，那么就无需往下更新了，因为做的是无用功。

反思：

1.自己开始时的想法是：如果这一段的数不全为0，那么就往下更新，因为期望着在如若干操作之后，这些区间的值都会变成0，那么时间限制应该不成为题。然而这只是很幼稚的想法，如果x都是1111111111，那岂不是每一次都要往下更新到根节点，但值又不发生任何改变，即做了很多无用功。

2.计算机都讲究效率，我们想只做有用功。所以，就必须清楚哪些是有用功，哪些是无用功。对于此题，如果x不能改变当前段的任何一个值，那么执行它就是无用功了。所以，在线段树的每个节点中，记录有哪些位的值为1，当x的此位也为1，那么次操作就是有用功，否则是无用功。

3.线段树的结点，就是记录当前段，或者说当前集合的公共信息，常见是最大最小值、和，当然还可以是很多天马行空的信息，要大胆想。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef long long LL;
const double EPS = 1e-8;
const int Int_Max = (1<<31)-1;
const int INF = 2e9;
const LL LNF = 2e18;
const int MAXN = 1e5+10;

int minv[MAXN<<2], state[MAXN<<2];
void push_up(int u)
{
    minv[u] = min(minv[u*2], minv[u*2+1]);
    state[u] = state[u*2]|state[u*2+1];     //信息集合
}

void build(int u, int l, int r)
{
    if(l==r)
    {
        scanf("%d", &minv[u]);
        state[u] = minv[u];
        return;
    }

    int mid = (l+r)>>1;
    build(u*2, l, mid);
    build(u*2+1, mid+1, r);
    push_up(u);
}

void add(int u, int l, int r, int x, int y, int val)
{
    int tmpDel = state[u]&val;  //对当前段与删除标签进行求与，得到的即为当前段可置0的位置的集合
    if(tmpDel==0) return;   //如果没有位置可以置为0，则直接退出
    if(l==r)
    {
        minv[u] ^= tmpDel;
        state[u] ^= tmpDel;
        return;
    }

    int mid = (l+r)>>1;
    if(x<=mid) add(u*2, l, mid, x, y, val);
    if(y>=mid+1) add(u*2+1, mid+1, r, x, y, val);
    push_up(u);
}

int query(int u, int l, int r, int x, int y)
{
    if(x<=l && r<=y)
        return minv[u];

    int ret = INF;
    int mid = (l+r)>>1;
    if(x<=mid) ret = min(ret, query(u*2, l, mid, x, y));
    if(y>=mid+1) ret = min(ret, query(u*2+1, mid+1, r, x, y));
    push_up(u);
    return ret;
}

int main()
{
    int n, m;
    scanf("%d%d", &n,&m);
    build(1,1,n);
    int op, L, R, val;
    while(m--)
    {
        scanf("%d", &op);
        if(op==0)
        {
            scanf("%d%d", &L, &R);
            printf("%d
", query(1,1,n,L,R));
        }
        else
        {
            scanf("%d%d%d", &L,&R,&val);
            add(1,1,n,L,R,(val^Int_Max));   //对val进行按位取反。
        }
    }
}