P1816 忠诚

P1816 忠诚

题目描述

老管家是一个聪明能干的人。他为财主工作了整整10年，财主为了让自已账目更加清楚。要求管家每天记k次账，由于管家聪明能干，因而管家总是让财主十分满意。但是由于一些人的挑拨，财主还是对管家产生了怀疑。于是他决定用一种特别的方法来判断管家的忠诚，他把每次的账目按1，2，3…编号，然后不定时的问管家问题，问题是这样的：在a到b号账中最少的一笔是多少？为了让管家没时间作假他总是一次问多个问题。

输入输出格式

输入格式：

输入中第一行有两个数m,n表示有m(m<=100000)笔账,n表示有n个问题，n<=100000。

第二行为m个数,分别是账目的钱数

后面n行分别是n个问题,每行有2个数字说明开始结束的账目编号。

输出格式：

输出文件中为每个问题的答案。具体查看样例。

输入输出样例

输入样例#1： 复制

10 3
1 2 3 4 5 6 7 8 9 10
2 7
3 9
1 10

输出样例#1： 复制

2 3 1

测试数据还有：

100 100
30634 1463 36025 59785 78967 ...

80 93
52 77
79 93
2 4
1 73

...

...

求区间最小值，线段树，树状数组都行。

这里的树状数组记录的就是前面部分中最小的，或者说是前缀中最小的。

洛谷题解：

好吧，老是用线段树就没意思了。

这道题又不需要对区间进行修改操作

直接用树状数组就行了

每个节点都是lowbit上来的点的最小值即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include <bits/stdc++.h>
using namespace std;
int a[1000001];    
int tree[1000001];   
int n,m;
void printA(){
    cout<<"a数组："<<endl;
    cout<<setw(10)<<" i:"<<" ";
    for(int i=1;i<=n;i++){
        cout<<i<<" ";
    } 
    cout<<endl;
    cout<<setw(10)<<" a[i]:"<<" ";
    for(int i=1;i<=n;i++){
        cout<<a[i]<<" ";
    } 
    cout<<endl;
}
void printTree(){
    cout<<"tree数组："<<endl;
    cout<<setw(10)<<" i:"<<" ";
    for(int i=1;i<=n;i++){
        cout<<i<<" ";
    } 
    cout<<endl;
    cout<<setw(10)<<" tree[i]:"<<" ";
    for(int i=1;i<=n;i++){
        cout<<tree[i]<<" ";
    } 
    cout<<endl;
}
int lowbit(int x)
{
    return x&(-x);
}
//update(i,a[i]);
void update(int x,int v)
{
    printTree();
    cout<<"x: "<<x<<"     v:"<<v<<endl;
    while(x<=n)
    {
        if(tree[x]>v)
          tree[x]=v;
         else
          return;     
        x+=lowbit(x);  
    }
}
int getmin(int x,int y)
{
    int now=y;
    int maxl=2147483647;
    //如果区间尾大于区间头 
    while(now>=x)
    {
        //如果能跳到前一级区间，前一级区间没有越界 
        if(now-lowbit(now)>x)
        {
           maxl=min(maxl,tree[now]);
           now-=lowbit(now);
        }
        //如果不能跳，就往前遍历 
        else
        {
            maxl=min(maxl,a[now]);
            --now;
        }
    }
    return maxl;
}

int main()
{
    freopen("in2.txt","r",stdin);
    memset(tree,127,sizeof(tree));
    cin>>n>>m;
    int x,y;
    //n++;
    cout<<endl<<"----------初始化树状数组----------"<<endl<<endl;
    for(int i=1;i<=n;++i)
    {
        cin>>a[i];
        update(i,a[i]);
    }
    printTree();
    printA(); 
    //tree数组记录的是区间的最小值 
    cout<<endl<<"----------求区间最小----------"<<endl<<endl; 
    for(;m>0;--m)
    {
        cin>>x>>y;
        cout<<getmin(x,y)<<' ';
    }
    return 0; 
}

 运行过程：

----------初始化树状数组----------

tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 2139062143 2139062143 2139062143 2139062143 2139062143 2139062143 2139062143 2139062143 2139062143 2139062143
x: 1 v:1
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 2139062143 1 2139062143 2139062143 2139062143 1 2139062143 2139062143
x: 2 v:2
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 2139062143 1 2139062143 2139062143 2139062143 1 2139062143 2139062143
x: 3 v:3
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 2139062143 2139062143 2139062143 1 2139062143 2139062143
x: 4 v:4
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 2139062143 2139062143 2139062143 1 2139062143 2139062143
x: 5 v:5
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 2139062143 1 2139062143 2139062143
x: 6 v:6
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 2139062143 1 2139062143 2139062143
x: 7 v:7
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 7 1 2139062143 2139062143
x: 8 v:8
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 7 1 2139062143 2139062143
x: 9 v:9
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 7 1 9 9
x: 10 v:10
tree数组：
i: 1 2 3 4 5 6 7 8 9 10
tree[i]: 1 1 3 1 5 5 7 1 9 9
a数组：
i: 1 2 3 4 5 6 7 8 9 10
a[i]: 1 2 3 4 5 6 7 8 9 10

----------求区间最小----------

2 3 1

这里的树状数组记录的就是前面部分中最小的，或者说是前缀中最小的。

来一个不太一样的解法：离线+单调队列。

先把所有询问读进来按右端点排序（这里我用了基数排序），然后按顺序将每个点插入队列。插入队列的时候如果队尾的元素的大于待插入的元素就弹出，这样就保证队列内的元素是递增的。

对于每个询问，在这个询问的右端点被插入后，在队列中二分下标大于等于左端点的第一个数，由于队列是递增的，所以二分出来的数就是答案。

这样做常数要比线段树小很多。

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
struct data{int l,num;}; vector<data> G[100001];
int a[100001],ans[100001],Q[100001],l=1,r=0;
int main(){
    int n,m; scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i) scanf("%d",&a[i]);
    for(int i=1;i<=m;++i){
        int l,r; scanf("%d%d",&l,&r); G[r].push_back({l,i});
    }
    for(int i=1;i<=n;++i){
        for(;l<=r&&a[Q[r]]>=a[i];--r); Q[++r]=i;
        for(int j=0;j<G[i].size();++j) ans[G[i][j].num]=a[*lower_bound(Q+l,Q+r+1,G[i][j].l)];
    }
    for(int i=1;i<=m;++i) printf("%d ",ans[i]); return 0;
}