UVa 12299 RMQ with Shifts(线段树)
线段树,没了..
-----------------------------------------------------------------------------------------
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cctype>
#define rep(i,n) for(int i=0;i<n;i++)
#define clr(x,c) memset(x,c,sizeof(x))
#define Rep(i,l,r) for(int i=l;i<=r;i++)
using namespace std;
const int inf=0x7fffffff;
const int maxn=100005;
int a[maxn];
int minv[1<<18];
void build(int o,int l,int r) {
int m=l+(r-l)/2;
if(l==r) minv[o]=a[l];
else {
build(o*2,l,m);
build(o*2+1,m+1,r);
minv[o]=min(minv[o*2],minv[o*2+1]);
}
}
int p,v;
void update(int o,int l,int r) {
int m=l+(r-l)/2;
if(l==r) minv[o]=v;
else {
p<=m ? update(o*2,l,m) : update(o*2+1,m+1,r);
minv[o]=min(minv[o*2],minv[o*2+1]);
}
}
int ql,qr;
int query(int o,int l,int r) {
int m=l+(r-l)/2,ans=inf;
if(ql<=l && qr>=r) return minv[o];
if(ql<=m) ans=min(ans,query(o*2,l,m));
if(qr>m) ans=min(ans,query(o*2+1,m+1,r));
return ans;
}
int main()
{
freopen("test.in","r",stdin);
freopen("test.out","w",stdout);
int n,q;
scanf("%d%d",&n,&q);
Rep(i,1,n) scanf("%d",&a[i]);
build(1,1,n);
int cmd[20],change[20],cnt;
char s[100];
while(q--) {
scanf("%s",s);
int len=strlen(s);
cmd[cnt=0]=0;
for(int i=6;i<len;++i)
if(isdigit(s[i])) (cmd[cnt]*=10)+=s[i]-'0';
else cmd[++cnt]=0;
if(s[0]=='q') {
ql=cmd[0],qr=cmd[1];
printf("%d\n",query(1,1,n));
} else {
rep(i,cnt) change[i]=a[cmd[i]];
rep(i,cnt) { v=a[p=cmd[i]]=change[(i+1)%cnt]; update(1,1,n); }
}
}
return 0;
}
-----------------------------------------------------------------------------------------
12299 RMQ with Shifts
In the traditional RMQ (Range Minimum Query) problem, we have a static array A. Then for each
query (L, R) (L ≤ R), we report the minimum value among A[L], A[L + 1], …, A[R]. Note that the
indices start from 1, i.e. the left-most element is A[1].
In this problem, the array A is no longer static: we need to support another operation
shif t(i1, i2, i3, . . . , ik)(i1 < i2 < . . . < ik, k > 1)
we do a left “circular shift” of A[i1], A[i2], …, A[ik].
For example, if A={6, 2, 4, 8, 5, 1, 4}, then shif t(2, 4, 5, 7) yields {6, 8, 4, 5, 4, 1, 2}. After that,
shif t(1, 2) yields 8, 6, 4, 5, 4, 1, 2.
Input
There will be only one test case, beginning with two integers n, q (1 ≤ n ≤ 100, 000, 1 ≤ q ≤ 250, 000),
the number of integers in array A, and the number of operations. The next line contains n positive
integers not greater than 100,000, the initial elements in array A. Each of the next q lines contains an
operation. Each operation is formatted as a string having no more than 30 characters, with no space
characters inside. All operations are guaranteed to be valid.
Warning: The dataset is large, better to use faster I/O methods.
Output
For each query, print the minimum value (rather than index) in the requested range.
Sample Input
7 5
6 2 4 8 5 1 4
query(3,7)
shift(2,4,5,7)
query(1,4)
shift(1,2)
query(2,2)
Sample Output
1
4
6
