ACM-ICPC北京赛区(2017)网络赛_Minimum

题目9 : Minimum

时间限制:1000ms

单点时限:1000ms

内存限制:256MB

描述

You are given a list of integers a0, a1, …, a2^k-1.

You need to support two types of queries:

1. Output Minx,y∈[l,r] {ax∙ay}.

2. Let ax=y.

输入

The first line is an integer T, indicating the number of test cases. (1≤T≤10).

For each test case:

The first line contains an integer k (0 ≤ k ≤ 17).

The following line contains 2k integers, a0, a1, …, a2^k-1 (-2k ≤ ai < 2k).

The next line contains a integer  (1 ≤ Q < 2k), indicating the number of queries. Then next Q lines, each line is one of:

1. 1 l r: Output Minx,y∈[l,r]{ax∙ay}. (0 ≤ l ≤ r < 2k)

2. 2 x y: Let ax=y. (0 ≤ x < 2k, -2k ≤ y < 2k)

输出

For each query 1, output a line contains an integer, indicating the answer.

样例输入

1
3
1 1 2 2 1 1 2 2
5
1 0 7
1 1 2
2 1 2
2 2 2
1 1 2

样例输出

1
1
4

典型的线段树单点更新与区间最大（小）值，没什么奥妙，但是自己还是打挫了，连WA带T13发，233，最终在一位小姐姐的指导小改掉一些细节错误成功A一发

附上AC代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<cstring>

using namespace std;

const int MAXNODE = (1<<20)+5;
const int MAX = 2e7+10;//2*10^6+10
const int INF = 0x7fffffff;

struct NODE{
    int maxvalue, minvalue;
    int left, right;
}node[MAXNODE];

int father[MAX];


void BuildTree(int i, int left, int right)
{
    node[i].minvalue = INF;
    node[i].maxvalue = -INF;
    node[i].left = left;
    node[i].right = right;
    if(right == left)
    {
        father[left] = i;
        return;
    }
    BuildTree(i<<1, left, (int)(floor(left+right)/2.0));
    BuildTree((i<<1)+1, (int)(floor(left+right)/2.0)+1, right);
}


//自底向上更新
void UpdateTree(int ri)
{
    if(ri <= 1)
        return;
    int fi = ri/2;
    int a = node[fi<<1].maxvalue;
    int b = node[(fi<<1)+1].maxvalue;
    node[fi].maxvalue = max(a, b);
    a = node[fi<<1].minvalue;
    b = node[(fi<<1)+1].minvalue;
    node[fi].minvalue = min(a, b);
    UpdateTree(ri/2);
}


int Max, Min;


//自顶向上查询
void Query_max(int i, int l, int r)
{
    if(node[i].left == l && node[i].right == r)
    {
        Max = max(Max, node[i].maxvalue);
        return;
    }

    i <<= 1;
    if(l <= node[i].right)
    {
        if(r <= node[i].right)
        {
            Query_max(i, l, r);
        }
        else
        {
            Query_max(i, l, node[i].right);
        }
    }
    i++;
    if(r >= node[i].left)
    {
        if(l >= node[i].left)
        {
            Query_max(i, l, r);
        }
        else
        {
            Query_max(i, node[i].left, r);
        }
    }
}


void Query_min(int i, int l, int r)
{
    if(node[i].left == l && node[i].right == r)
    {
        Min = min(Min, node[i].minvalue);
        return;
    }

    i <<= 1;
    if(l <= node[i].right)
    {
        if(r <= node[i].right)
        {
            Query_min(i, l, r);
        }
        else
        {
            Query_min(i, l, node[i].right);
        }
    }
    i++;
    if(r >= node[i].left)
    {
        if(l >= node[i].left)
        {
            Query_min(i, l, r);
        }
        else
        {
            Query_min(i, node[i].left, r);
        }
    }
}


int main()
{
    int k, t, n, g, a, b, c;
    long long ans;
    ios::sync_with_stdio(false);
    cin>>t;
    //cout<<INF<<-INF<<endl;
    while(t--)
    {
        cin>>k;
        BuildTree(1, 1, 1<<k);
        for(int i = 1; i <= 1<<k; i++)
        {
            cin>>g;
            node[father[i]].maxvalue = node[father[i]].minvalue = g;
            UpdateTree(father[i]);
        }
        cin>>n;
        for(int i = 1; i <= n; i++)
        {
            Max = -INF;
            Min = INF;
            cin>>a>>b>>c;
            if(a == 1)
            {
                Query_max(1, b+1, c+1);
                Query_min(1, b+1, c+1);
                //cout<<Max<<" "<<Min<<endl;
                if(Max <= 0)
                {
                    ans = (long long)Max*Max;
                    cout<<ans<<endl;
                }
                else if(Min >= 0)
                {
                    ans = (long long)Min*Min;
                    cout<<ans<<endl;
                }
                else
                {
                    ans = (long long)Min*Max;
                    cout<<ans<<endl;
                }
            }
            else if(a == 2)
            {
                node[father[b+1]].maxvalue = node[father[b+1]].minvalue = c;
                UpdateTree(father[b+1]);
            }
        }
    }
return 0;
}