E1. Array and Segments (Easy version)（暴力） && E2. Array and Segments (Hard version)（线段树维护）

题目链接：

E1：http://codeforces.com/contest/1108/problem/E1

E2：http://codeforces.com/contest/1108/problem/E2

题目大意：

给你n个数，然后给你m个区间，每一个区间代表将给定的n个数这个区间内都减去1，每个区间最多使用一次。然后问你使用哪些区间能够使得这n个数中最大数和最小的差值最大？

首先对于E1：这么小的数据不暴力搞啥？？直接问枚举就完事了，每一次枚举的时候保持一个数不变，假设当前的数是最大的，然后其他的只要是不包含这个数的区间，都减去，这样就能让最小的那个位置尽可能的小了。

AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 # define ll long long
 # define inf 0x3f3f3f3f
 const int maxn = +;
 int a[maxn],b[maxn],sto[maxn];
 struct node
 {
     int le;
     int ri;
 } q[maxn];
 int main()
 {
     int n,m;
     scanf("%d %d",&n,&m);
     for(int i=; i<=n; i++)
     {
         scanf("%d",&a[i]);
     }
     for(int i=; i<=m; i++)
     {
         scanf("%d %d",&q[i].le,&q[i].ri);
     }
     int maxx=-inf,id=;
     for(int i=; i<=n; i++)
     {
         int t1=-inf,t2=inf;
         for(int j=; j<=n; j++)
         {
             b[j]=a[j];
         }
         for(int j=; j<=m; j++)
         {
             if(i>=q[j].le&&i<=q[j].ri)
                 continue;
             for(int k=q[j].le; k<=q[j].ri; k++)
             {
                 b[k]-=;
             }
         }
         for(int j=; j<=n; j++)
         {
             t1=max(t1,b[j]);
             t2=min(t2,b[j]);
         }
         if(t1-t2>maxx)
         {
             maxx=t1-t2;
             id=i;
         }
     }
   //  cout<<m<<endl;
     printf("%d\n",maxx);
     int num=;
   //  cout<<1<<" "<<num<<endl;
     for(int i=; i<=m; i++)
     {
         if(id>=q[i].le&&id<=q[i].ri)
             continue;
           //  cout<<1<<endl;
         sto[++num]=i;
     }
   //  cout<<2<<" "<<num<<endl;
     printf("%d\n",num);
     for(int i=; i<=num; i++)
     {
         if(i==)
             printf("%d",sto[i]);
         else
             printf(" %d",sto[i]);
     }
     printf("\n");
     return ;
 }

其次对于E2：我们可以寻找最小的数的位置，这个时候为什么不和E1一样去找最大的数的位置呢？因为我们要利用区间的性质，对于每一个节点，我们需要从第一个位置开始。

对于当枚举到第i个节点的时候，需要把包括i的区间都给整上，这个时候求一下最值之差，当枚举到第i+1个节点的时候，我们只需要把不包括第i个节点但是包括第i+1个节点的区间给整上就可以了，这样就能省去很多不必要的操作了。

AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 # define ll long long
 # define inf 0x3f3f3f3f
 # define lson l,m,rt<<
 # define rson m+,r,rt<<|
 const int maxn = 1e5+;
 int minn[maxn<<],maxx[maxn<<],dif[maxn<<];
 int lazy[maxn<<];
 struct node
 {
     int le;
     int ri;
 } edge[+];
 int sto[maxn];
 int ans1,ans2;
 vector<int>q1[maxn],q2[maxn];
 void up(int rt)
 {
     minn[rt]=min(minn[rt<<],minn[rt<<|]);
     maxx[rt]=max(maxx[rt<<],maxx[rt<<|]);
     dif[rt]=maxx[rt]-minn[rt];// 本来查找最值得差的时候是直接询问到底部的，加了这个就不需要了，学到了！！
 }
 void build(int l,int r,int rt)
 {
     if(l==r)
     {
         int tmp;
         scanf("%d",&tmp);
         minn[rt]=tmp;
         maxx[rt]=tmp;
         return ;
     }
     int m=(l+r)>>;
     build(lson);
     build(rson);
     up(rt);
 }
 void down(int rt)
 {
     if(lazy[rt])
     {
         lazy[rt<<]+=lazy[rt];
         lazy[rt<<|]+=lazy[rt];
         minn[rt<<]+=lazy[rt];
         minn[rt<<|]+=lazy[rt];
         maxx[rt<<]+=lazy[rt];
         maxx[rt<<|]+=lazy[rt];
         lazy[rt]=;
     }
 }
 void update(int l,int r,int rt,int L,int R,int p)
 {
     if(L<=l&&R>=r)
     {
         minn[rt]+=p;
         maxx[rt]+=p;
         lazy[rt]+=p;
         return ;
     }
     down(rt);
     int m=(l+r)>>;
     if(L<=m)
         update(lson,L,R,p);
     if(R>m)
         update(rson,L,R,p);
     up(rt);
 }
 //int querymax(int l,int r,int rt)
 //{
 //    if(l==r)
 //    {
 //        return  maxx[rt];
 //    }
 //    int t1;
 //    down(rt);
 //    int m=(l+r)>>1;
 //    if(l<=m)querymax(lson);
 //    if(r>m)querymax(rson);
 //    up(rt);
 //}
 //void querymin(int l,int r,int rt)
 //{
 //    if(l==r)
 //    {
 //        ans2=min(ans2,minn[rt]);
 //        return ;
 //    }
 //    down(rt);
 //    int m=(l+r)>>1;
 //    querymin(lson);
 //   querymin(rson);
 //    up(rt);
 //}
 int main()
 {
     int n,m,tmp,len;
     scanf("%d %d",&n,&m);
     build(,n,);
     int ans=-inf,id=;
     for(int i=; i<=m; i++)
     {
         scanf("%d %d",&edge[i].le,&edge[i].ri);
         q1[edge[i].le].push_back(i);
         q2[edge[i].ri].push_back(i);
     }
     for(int i=; i<=n; i++)
     {
         len=q2[i-].size();
         for(int j=; j<len; j++)
         {
             tmp=q2[i-][j];
             update(,n,,edge[tmp].le,edge[tmp].ri,);
         }
         len=q1[i].size();
         for(int j=; j<len; j++)
         {
             tmp=q1[i][j];
             update(,n,,edge[tmp].le,edge[tmp].ri,-);
         }
         if(ans<dif[])
         {
             ans=dif[];
             id=i;
         }
     }
     int num=;
    printf("%d\n",ans);
     for(int i=; i<=m; i++)
     {
         if(edge[i].le<=id&&edge[i].ri>=id)
         {
             sto[++num]=i;
         }
     }
     printf("%d\n",num);
     for(int i=; i<=num; i++)
     {
         if(i==)
             printf("%d",sto[i]);
         else
             printf(" %d",sto[i]);
     }
     printf("\n");
     return ;
 }