[hihocoder 1070]RMQ问题再临

最新推荐文章于 2017-08-15 13:40:10 发布

silent56_th

最新推荐文章于 2017-08-15 13:40:10 发布

阅读量308

点赞数

CC 4.0 BY-SA版权

分类专栏： hihocoder 线段树文章标签： RMQ hihocoder 线段树

本文链接：https://blog.youkuaiyun.com/silent56_th/article/details/53931793

hihocoder 同时被 2 个专栏收录

22 篇文章

订阅专栏

线段树

2 篇文章

订阅专栏

本文通过一个具体的购物场景问题，详细介绍了如何使用线段树进行高效的数据查询与更新操作。通过对线段树的构建、查询及节点更新等关键步骤的剖析，展示了线段树在解决区间查询与动态更新问题中的应用技巧。

问题描述

时间限制:10000ms
单点时限:1000ms
内存限制:256MB
描述

终于，小Hi和小Ho踏上了回国的旅程。在飞机上，望着采购来的特产——小Hi陷入了沉思：还记得在上上周他们去超市的时候，前前后后挑了那么多的东西，都幸运的没有任何其他人（售货员/其他顾客）来打搅他们的采购过程。但是如果发生了这样的事情，他们的采购又会变得如何呢？

于是小Hi便向小Ho提出了这个问题：假设整个货架上从左到右摆放了N种商品，并且依次标号为1到N，每次小Hi都给出一段区间[L, R]，小Ho要做的是选出标号在这个区间内的所有商品重量最轻的一种，并且告诉小Hi这个商品的重量。但是在这个过程中，可能会因为其他人的各种行为，对某些位置上的商品的重量产生改变（如更换了其他种类的商品），面对这样一个问题，小Ho又该如何解决呢？

提示：平衡乃和谐之理

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为一个整数N，意义如前文所述。

每组测试数据的第2行为N个整数，分别描述每种商品的重量，其中第i个整数表示标号为i的商品的重量weight_i。

每组测试数据的第3行为一个整数Q，表示小Hi总共询问的次数与商品的重量被更改的次数之和。

每组测试数据的第N+4~N+Q+3行，每行分别描述一次操作，每行的开头均为一个属于0或1的数字，分别表示该行描述一个询问和描述一次商品的重量的更改两种情况。对于第N+i+3行，如果该行描述一个询问，则接下来为两个整数Li, Ri，表示小Hi询问的一个区间[Li, Ri]；如果该行描述一次商品的重量的更改，则接下来为两个整数Pi，Wi，表示位置编号为Pi的商品的重量变更为Wi

对于100%的数据，满足N<=10^4，Q<=10^4, 1<=Li<=Ri<=N，1<=Pi<=N, 0

算法详解

穷搜即可，但是作者想要练习一下线段树，下面就是利用线段树解题（或者说作者自己理解的，作者在码代码之前只简略的看了一下相关博客，然后自己实现了一下）。作者对于线段树的理解是主要在于可以对二分搜索的剪枝，所以事先构造一个二分搜索树，存储中间变量，对于新的搜索则尽可能利用中间变量剪枝。

全部代码

#include <iostream>
#include <queue>
#include <stack>
#include <cstdlib>
#include <time.h>

using namespace std;

int arr[10002],N;

struct Node {
    int mmin;
    int l,r;
    Node *left, *right;

    Node():mmin(-1),l(-1),r(-1),left(NULL),right(NULL) {}
    Node(int ll,int rr):mmin(-1),l(ll),r(rr),left(NULL),right(NULL) {}
    ~Node() {}
    Node(const Node &n):mmin(n.mmin),l(n.l),r(n.r),left(n.left),right(n.right) {}

    void print() {
        cout << l << '\t' << r << '\t' << mmin << endl;
    }
};

struct Tree {
    Node *root;

    Tree():root(NULL) {}
    Tree(const Tree &t):root(t.root) {}
    ~Tree() {clean(root);}

    void clean(Node*r) {
        if (!r)
            return;
        clean(r->left);
        clean(r->right);
        delete r;
    }

    void build_tree(Node* n) {
        if (n->l == n->r) {
            n->mmin = arr[n->l];
            return;
        }
        if (n->l == n->r-1){
            n->left = new Node(n->l,n->l);
            n->right = new Node(n->r,n->r);
            n->left->mmin = arr[n->l];
            n->right->mmin = arr[n->r];
            n->mmin = min(arr[n->l],arr[n->r]);
        }
        int mid = (n->l+n->r)/2;
        n->left = new Node(n->l,mid);
        build_tree(n->left);
        n->right = new Node(mid+1,n->r);
        build_tree(n->right);

        n->mmin = min(n->left->mmin,n->right->mmin);
    }

    void build_tree() {
        clean(root);
        root = new Node(0,N-1);
        build_tree(root);
    }

    int get_min(int l,int r) {
        return get_min(root,l,r);
    }

    int get_min(Node*n,int l,int r) {
        if (l == r) {
            return arr[l];
        }
        if (l == r-1) {
            return min(arr[l],arr[r]);
        }

        if (r < n->right->l)
            return get_min(n->left,l,r);
        if (l > n->left->r)
            return get_min(n->right,l,r);
        if (l == n->l && r == n->r)
            return n->mmin;
        return min(get_min(n->left,l,n->left->r),get_min(n->right,n->right->l,r));
    }

    void update_node(int index,int value) {
        Node *n = root;
        stack<Node*> s;
        while (n->l != n->r) {
            s.push(n);
            if (index < n->right->l)
                n = n->left;
            else
                n = n->right;
        }
        n->mmin = value;
        arr[index] = value;
        while (!s.empty()) {
            n = s.top();
            s.pop();
            n->mmin = min(n->left->mmin,n->right->mmin);
//            cout << n->l << ' ' << n->r << ' ' << n->mmin << endl;
        }
    }

    void print_tree() {
        cout << "Tree: " << endl;
        queue<Node*> q;
        q.push(root);
        Node* tmp;

        while (!q.empty()) {
            tmp = q.front();
            q.pop();
            tmp->print();
            if (tmp->left)
                q.push(tmp->left);
            if (tmp->right)
                q.push(tmp->right);
        }
    }
};

/***search***/
int get_min(int l,int r){
    int result = arr[l];
    for (int i = l;i <= r;++i)
        if (result > arr[i])
            result = arr[i];
    return result;
}

void print_arr() {

    cout <<  "N: " << N << endl;
    for (int i = 0;i < N;++i)
        cout << arr[i] << ' ';
    cout << endl;

}

/***test***/
void test() {
    int seed = (int)time(0);
//    seed = 1483006823;
    cout << "seed: " << seed << endl;
    srand(seed);
    N = rand() % 20;
    for (int i = 0;i < N;++i)
        arr[i] = rand()%100;

    print_arr();

    Tree tree;
    tree.build_tree();

    int Q=rand()%20;
    int n1,n2,n3;
    for (int i = 0;i < Q;++i){
        n1 = rand()%2;
        if (n1 == 0) {
            n2 = rand()%N+1;
            n3 = rand()%N+1;
            if (n2 > n3) swap(n2,n3);
            if (tree.get_min(n2-1,n3-1) != get_min(n2-1,n3-1)) {
                print_arr();
                cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << tree.get_min(n2-1,n3-1) << ' ' << get_min(n2-1,n3-1) << endl;
            }

        }
        else {
            n2 = rand()%N+1;
            n3 = rand()%100;

            tree.update_node(n2-1,n3);
            if (arr[n2-1] != n3)
                cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << arr[n2-1] << endl;
        }

    }
}

int main()
{
    Tree tree;

    cin >> N;
    for (int i = 0;i < N;++i)
        cin >> arr[i];

    tree.build_tree();
//    tree.print_tree();

    int Q;
    cin >> Q;

    int n1,n2,n3;
    for (int i = 0;i < Q;++i) {
        cin >> n1 >> n2 >> n3;
        if (n1 == 0) {
            cout << tree.get_min(n2-1,n3-1) << endl;
        }
        else {
            tree.update_node(n2-1,n3);
        }
    }


    /***test***/
//    test();
    return 0;
}