孙兆程吧 关注:105贴子:4,582

最大值问题

只看楼主收藏回复

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cmath>
using namespace std;
struct node
{
int l,r;
int Max;
int mid()
{
return (l+r)>>1;
}
}tree[4*100005];
int aa[100005];
void pushup (int id)
{
tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
}
void build(int id,int x,int y)
{
tree[id].l=x;
tree[id].r=y;
if (x==y)
{
tree[id].Max=aa[x];
return;
}
int mid=tree[id].mid();
build(id<<1,x,mid);
build(id<<1|1,mid+1,y);
pushup(id);
}
int query (int id,int x,int y)
{
if (tree[id].l==x&&tree[id].r==y)
return tree[id].Max;
int mid=tree[id].mid();
if (y<=mid)
return query (id<<1,x,y);
else
if (mid+1<=x)
return query(id<<1|1,x,y);
else
return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
}
void add (int id,int x,int num)
{
if (tree[id].l==tree[id].r&&tree[id].l==x)
{
tree[id].Max=num;
return;
}
int mid=tree[id].mid();
if (x<=mid)
add (id<<1,x,num);
else
add (id<<1|1,x,num);
pushup (id);
}
int main()
{
int t,n,m,op,a,b,i,j,k;
scanf ("%d",&t);
for (j=0;j<t;j++)
{
scanf ("%d",&n);
for (i=1;i<=n;i++)
scanf ("%d",&aa[i]);
build (1,1,n);
scanf ("%d",&m);
for (i=1;i<=m;i++)
{
scanf ("%d%d%d",&op,&a,&b);
if (op==1)
{
if (a<=b)
k=query (1,a,b);
else
k=max(query (1,a,n),query (1,1,b));
printf ("%d\n",k);
}
if (op==2)
add (1,a,b);
}
}
return 0;
}


IP属地:北京1楼2015-05-23 14:53回复
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <cstdlib>
    #include <cmath>
    using namespace std;
    struct node
    {
    int l,r;
    int Max;
    int mid()
    {
    return (l+r)>>1;
    }
    }tree[4*100005];
    int aa[100005];
    void pushup (int id)
    {
    tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
    }
    void build(int id,int x,int y)
    {
    tree[id].l=x;
    tree[id].r=y;
    if (x==y)
    {
    tree[id].Max=aa[x];
    return;
    }
    int mid=tree[id].mid();
    build(id<<1,x,mid);
    build(id<<1|1,mid+1,y);
    pushup(id);
    }
    int query (int id,int x,int y)
    {
    if (tree[id].l==x&&tree[id].r==y)
    return tree[id].Max;
    int mid=tree[id].mid();
    if (y<=mid)
    return query (id<<1,x,y);
    else
    if (mid+1<=x)
    return query(id<<1|1,x,y);
    else
    return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
    }
    void add (int id,int x,int num)
    {
    if (tree[id].l==tree[id].r&&tree[id].l==x)
    {
    tree[id].Max=num;
    return;
    }
    int mid=tree[id].mid();
    if (x<=mid)
    add (id<<1,x,num);
    else
    add (id<<1|1,x,num);
    pushup (id);
    }
    int main()
    {
    int t,n,m,op,a,b,i,j,k;
    scanf ("%d",&t);
    for (j=0;j<t;j++)
    {
    scanf ("%d",&n);
    for (i=1;i<=n;i++)
    scanf ("%d",&aa[i]);
    build (1,1,n);
    scanf ("%d",&m);
    for (i=1;i<=m;i++)
    {
    scanf ("%d%d%d",&op,&a,&b);
    if (op==1)
    {
    if (a<=b)
    k=query (1,a,b);
    else
    k=max(query (1,a,n),query (1,1,b));
    printf ("%d\n",k);
    }
    if (op==2)
    add (1,a,b);
    }
    }
    return 0;
    }


    IP属地:北京2楼2015-05-23 14:53
    回复
      2025-12-26 23:53:48
      广告
      不感兴趣
      开通SVIP免广告
      #include <cstdio>
      #include <cstring>
      #include <algorithm>
      #include <cstdlib>
      #include <cmath>
      using namespace std;
      struct node
      {
      int l,r;
      int Max;
      int mid()
      {
      return (l+r)>>1;
      }
      }tree[4*100005];
      int aa[100005];
      void pushup (int id)
      {
      tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
      }
      void build(int id,int x,int y)
      {
      tree[id].l=x;
      tree[id].r=y;
      if (x==y)
      {
      tree[id].Max=aa[x];
      return;
      }
      int mid=tree[id].mid();
      build(id<<1,x,mid);
      build(id<<1|1,mid+1,y);
      pushup(id);
      }
      int query (int id,int x,int y)
      {
      if (tree[id].l==x&&tree[id].r==y)
      return tree[id].Max;
      int mid=tree[id].mid();
      if (y<=mid)
      return query (id<<1,x,y);
      else
      if (mid+1<=x)
      return query(id<<1|1,x,y);
      else
      return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
      }
      void add (int id,int x,int num)
      {
      if (tree[id].l==tree[id].r&&tree[id].l==x)
      {
      tree[id].Max=num;
      return;
      }
      int mid=tree[id].mid();
      if (x<=mid)
      add (id<<1,x,num);
      else
      add (id<<1|1,x,num);
      pushup (id);
      }
      int main()
      {
      int t,n,m,op,a,b,i,j,k;
      scanf ("%d",&t);
      for (j=0;j<t;j++)
      {
      scanf ("%d",&n);
      for (i=1;i<=n;i++)
      scanf ("%d",&aa[i]);
      build (1,1,n);
      scanf ("%d",&m);
      for (i=1;i<=m;i++)
      {
      scanf ("%d%d%d",&op,&a,&b);
      if (op==1)
      {
      if (a<=b)
      k=query (1,a,b);
      else
      k=max(query (1,a,n),query (1,1,b));
      printf ("%d\n",k);
      }
      if (op==2)
      add (1,a,b);
      }
      }
      return 0;
      }


      IP属地:北京3楼2015-05-23 14:53
      回复
        #include <cstdio>
        #include <cstring>
        #include <algorithm>
        #include <cstdlib>
        #include <cmath>
        using namespace std;
        struct node
        {
        int l,r;
        int Max;
        int mid()
        {
        return (l+r)>>1;
        }
        }tree[4*100005];
        int aa[100005];
        void pushup (int id)
        {
        tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
        }
        void build(int id,int x,int y)
        {
        tree[id].l=x;
        tree[id].r=y;
        if (x==y)
        {
        tree[id].Max=aa[x];
        return;
        }
        int mid=tree[id].mid();
        build(id<<1,x,mid);
        build(id<<1|1,mid+1,y);
        pushup(id);
        }
        int query (int id,int x,int y)
        {
        if (tree[id].l==x&&tree[id].r==y)
        return tree[id].Max;
        int mid=tree[id].mid();
        if (y<=mid)
        return query (id<<1,x,y);
        else
        if (mid+1<=x)
        return query(id<<1|1,x,y);
        else
        return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
        }
        void add (int id,int x,int num)
        {
        if (tree[id].l==tree[id].r&&tree[id].l==x)
        {
        tree[id].Max=num;
        return;
        }
        int mid=tree[id].mid();
        if (x<=mid)
        add (id<<1,x,num);
        else
        add (id<<1|1,x,num);
        pushup (id);
        }
        int main()
        {
        int t,n,m,op,a,b,i,j,k;
        scanf ("%d",&t);
        for (j=0;j<t;j++)
        {
        scanf ("%d",&n);
        for (i=1;i<=n;i++)
        scanf ("%d",&aa[i]);
        build (1,1,n);
        scanf ("%d",&m);
        for (i=1;i<=m;i++)
        {
        scanf ("%d%d%d",&op,&a,&b);
        if (op==1)
        {
        if (a<=b)
        k=query (1,a,b);
        else
        k=max(query (1,a,n),query (1,1,b));
        printf ("%d\n",k);
        }
        if (op==2)
        add (1,a,b);
        }
        }
        return 0;
        }


        IP属地:北京4楼2015-05-23 14:53
        回复
          #include <cstdio>
          #include <cstring>
          #include <algorithm>
          #include <cstdlib>
          #include <cmath>
          using namespace std;
          struct node
          {
          int l,r;
          int Max;
          int mid()
          {
          return (l+r)>>1;
          }
          }tree[4*100005];
          int aa[100005];
          void pushup (int id)
          {
          tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
          }
          void build(int id,int x,int y)
          {
          tree[id].l=x;
          tree[id].r=y;
          if (x==y)
          {
          tree[id].Max=aa[x];
          return;
          }
          int mid=tree[id].mid();
          build(id<<1,x,mid);
          build(id<<1|1,mid+1,y);
          pushup(id);
          }
          int query (int id,int x,int y)
          {
          if (tree[id].l==x&&tree[id].r==y)
          return tree[id].Max;
          int mid=tree[id].mid();
          if (y<=mid)
          return query (id<<1,x,y);
          else
          if (mid+1<=x)
          return query(id<<1|1,x,y);
          else
          return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
          }
          void add (int id,int x,int num)
          {
          if (tree[id].l==tree[id].r&&tree[id].l==x)
          {
          tree[id].Max=num;
          return;
          }
          int mid=tree[id].mid();
          if (x<=mid)
          add (id<<1,x,num);
          else
          add (id<<1|1,x,num);
          pushup (id);
          }
          int main()
          {
          int t,n,m,op,a,b,i,j,k;
          scanf ("%d",&t);
          for (j=0;j<t;j++)
          {
          scanf ("%d",&n);
          for (i=1;i<=n;i++)
          scanf ("%d",&aa[i]);
          build (1,1,n);
          scanf ("%d",&m);
          for (i=1;i<=m;i++)
          {
          scanf ("%d%d%d",&op,&a,&b);
          if (op==1)
          {
          if (a<=b)
          k=query (1,a,b);
          else
          k=max(query (1,a,n),query (1,1,b));
          printf ("%d\n",k);
          }
          if (op==2)
          add (1,a,b);
          }
          }
          return 0;
          }


          IP属地:北京5楼2015-05-23 14:53
          回复
            #include <cstdio>
            #include <cstring>
            #include <algorithm>
            #include <cstdlib>
            #include <cmath>
            using namespace std;
            struct node
            {
            int l,r;
            int Max;
            int mid()
            {
            return (l+r)>>1;
            }
            }tree[4*100005];
            int aa[100005];
            void pushup (int id)
            {
            tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
            }
            void build(int id,int x,int y)
            {
            tree[id].l=x;
            tree[id].r=y;
            if (x==y)
            {
            tree[id].Max=aa[x];
            return;
            }
            int mid=tree[id].mid();
            build(id<<1,x,mid);
            build(id<<1|1,mid+1,y);
            pushup(id);
            }
            int query (int id,int x,int y)
            {
            if (tree[id].l==x&&tree[id].r==y)
            return tree[id].Max;
            int mid=tree[id].mid();
            if (y<=mid)
            return query (id<<1,x,y);
            else
            if (mid+1<=x)
            return query(id<<1|1,x,y);
            else
            return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
            }
            void add (int id,int x,int num)
            {
            if (tree[id].l==tree[id].r&&tree[id].l==x)
            {
            tree[id].Max=num;
            return;
            }
            int mid=tree[id].mid();
            if (x<=mid)
            add (id<<1,x,num);
            else
            add (id<<1|1,x,num);
            pushup (id);
            }
            int main()
            {
            int t,n,m,op,a,b,i,j,k;
            scanf ("%d",&t);
            for (j=0;j<t;j++)
            {
            scanf ("%d",&n);
            for (i=1;i<=n;i++)
            scanf ("%d",&aa[i]);
            build (1,1,n);
            scanf ("%d",&m);
            for (i=1;i<=m;i++)
            {
            scanf ("%d%d%d",&op,&a,&b);
            if (op==1)
            {
            if (a<=b)
            k=query (1,a,b);
            else
            k=max(query (1,a,n),query (1,1,b));
            printf ("%d\n",k);
            }
            if (op==2)
            add (1,a,b);
            }
            }
            return 0;
            }


            IP属地:北京6楼2015-05-23 14:54
            回复
              十五字十五字十五字十五字十五字


              IP属地:天津7楼2015-05-23 14:54
              回复
                #include <cstdio>
                #include <cstring>
                #include <algorithm>
                #include <cstdlib>
                #include <cmath>
                using namespace std;
                struct node
                {
                int l,r;
                int Max;
                int mid()
                {
                return (l+r)>>1;
                }
                }tree[4*100005];
                int aa[100005];
                void pushup (int id)
                {
                tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                }
                void build(int id,int x,int y)
                {
                tree[id].l=x;
                tree[id].r=y;
                if (x==y)
                {
                tree[id].Max=aa[x];
                return;
                }
                int mid=tree[id].mid();
                build(id<<1,x,mid);
                build(id<<1|1,mid+1,y);
                pushup(id);
                }
                int query (int id,int x,int y)
                {
                if (tree[id].l==x&&tree[id].r==y)
                return tree[id].Max;
                int mid=tree[id].mid();
                if (y<=mid)
                return query (id<<1,x,y);
                else
                if (mid+1<=x)
                return query(id<<1|1,x,y);
                else
                return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                }
                void add (int id,int x,int num)
                {
                if (tree[id].l==tree[id].r&&tree[id].l==x)
                {
                tree[id].Max=num;
                return;
                }
                int mid=tree[id].mid();
                if (x<=mid)
                add (id<<1,x,num);
                else
                add (id<<1|1,x,num);
                pushup (id);
                }
                int main()
                {
                int t,n,m,op,a,b,i,j,k;
                scanf ("%d",&t);
                for (j=0;j<t;j++)
                {
                scanf ("%d",&n);
                for (i=1;i<=n;i++)
                scanf ("%d",&aa[i]);
                build (1,1,n);
                scanf ("%d",&m);
                for (i=1;i<=m;i++)
                {
                scanf ("%d%d%d",&op,&a,&b);
                if (op==1)
                {
                if (a<=b)
                k=query (1,a,b);
                else
                k=max(query (1,a,n),query (1,1,b));
                printf ("%d\n",k);
                }
                if (op==2)
                add (1,a,b);
                }
                }
                return 0;
                }


                IP属地:北京8楼2015-05-23 14:54
                回复
                  2025-12-26 23:47:48
                  广告
                  不感兴趣
                  开通SVIP免广告
                  #include <cstdio>
                  #include <cstring>
                  #include <algorithm>
                  #include <cstdlib>
                  #include <cmath>
                  using namespace std;
                  struct node
                  {
                  int l,r;
                  int Max;
                  int mid()
                  {
                  return (l+r)>>1;
                  }
                  }tree[4*100005];
                  int aa[100005];
                  void pushup (int id)
                  {
                  tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                  }
                  void build(int id,int x,int y)
                  {
                  tree[id].l=x;
                  tree[id].r=y;
                  if (x==y)
                  {
                  tree[id].Max=aa[x];
                  return;
                  }
                  int mid=tree[id].mid();
                  build(id<<1,x,mid);
                  build(id<<1|1,mid+1,y);
                  pushup(id);
                  }
                  int query (int id,int x,int y)
                  {
                  if (tree[id].l==x&&tree[id].r==y)
                  return tree[id].Max;
                  int mid=tree[id].mid();
                  if (y<=mid)
                  return query (id<<1,x,y);
                  else
                  if (mid+1<=x)
                  return query(id<<1|1,x,y);
                  else
                  return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                  }
                  void add (int id,int x,int num)
                  {
                  if (tree[id].l==tree[id].r&&tree[id].l==x)
                  {
                  tree[id].Max=num;
                  return;
                  }
                  int mid=tree[id].mid();
                  if (x<=mid)
                  add (id<<1,x,num);
                  else
                  add (id<<1|1,x,num);
                  pushup (id);
                  }
                  int main()
                  {
                  int t,n,m,op,a,b,i,j,k;
                  scanf ("%d",&t);
                  for (j=0;j<t;j++)
                  {
                  scanf ("%d",&n);
                  for (i=1;i<=n;i++)
                  scanf ("%d",&aa[i]);
                  build (1,1,n);
                  scanf ("%d",&m);
                  for (i=1;i<=m;i++)
                  {
                  scanf ("%d%d%d",&op,&a,&b);
                  if (op==1)
                  {
                  if (a<=b)
                  k=query (1,a,b);
                  else
                  k=max(query (1,a,n),query (1,1,b));
                  printf ("%d\n",k);
                  }
                  if (op==2)
                  add (1,a,b);
                  }
                  }
                  return 0;
                  }


                  IP属地:北京9楼2015-05-23 14:54
                  回复
                    #include <cstdio>
                    #include <cstring>
                    #include <algorithm>
                    #include <cstdlib>
                    #include <cmath>
                    using namespace std;
                    struct node
                    {
                    int l,r;
                    int Max;
                    int mid()
                    {
                    return (l+r)>>1;
                    }
                    }tree[4*100005];
                    int aa[100005];
                    void pushup (int id)
                    {
                    tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                    }
                    void build(int id,int x,int y)
                    {
                    tree[id].l=x;
                    tree[id].r=y;
                    if (x==y)
                    {
                    tree[id].Max=aa[x];
                    return;
                    }
                    int mid=tree[id].mid();
                    build(id<<1,x,mid);
                    build(id<<1|1,mid+1,y);
                    pushup(id);
                    }
                    int query (int id,int x,int y)
                    {
                    if (tree[id].l==x&&tree[id].r==y)
                    return tree[id].Max;
                    int mid=tree[id].mid();
                    if (y<=mid)
                    return query (id<<1,x,y);
                    else
                    if (mid+1<=x)
                    return query(id<<1|1,x,y);
                    else
                    return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                    }
                    void add (int id,int x,int num)
                    {
                    if (tree[id].l==tree[id].r&&tree[id].l==x)
                    {
                    tree[id].Max=num;
                    return;
                    }
                    int mid=tree[id].mid();
                    if (x<=mid)
                    add (id<<1,x,num);
                    else
                    add (id<<1|1,x,num);
                    pushup (id);
                    }
                    int main()
                    {
                    int t,n,m,op,a,b,i,j,k;
                    scanf ("%d",&t);
                    for (j=0;j<t;j++)
                    {
                    scanf ("%d",&n);
                    for (i=1;i<=n;i++)
                    scanf ("%d",&aa[i]);
                    build (1,1,n);
                    scanf ("%d",&m);
                    for (i=1;i<=m;i++)
                    {
                    scanf ("%d%d%d",&op,&a,&b);
                    if (op==1)
                    {
                    if (a<=b)
                    k=query (1,a,b);
                    else
                    k=max(query (1,a,n),query (1,1,b));
                    printf ("%d\n",k);
                    }
                    if (op==2)
                    add (1,a,b);
                    }
                    }
                    return 0;
                    }


                    IP属地:北京10楼2015-05-23 14:54
                    回复
                      #include <cstdio>
                      #include <cstring>
                      #include <algorithm>
                      #include <cstdlib>
                      #include <cmath>
                      using namespace std;
                      struct node
                      {
                      int l,r;
                      int Max;
                      int mid()
                      {
                      return (l+r)>>1;
                      }
                      }tree[4*100005];
                      int aa[100005];
                      void pushup (int id)
                      {
                      tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                      }
                      void build(int id,int x,int y)
                      {
                      tree[id].l=x;
                      tree[id].r=y;
                      if (x==y)
                      {
                      tree[id].Max=aa[x];
                      return;
                      }
                      int mid=tree[id].mid();
                      build(id<<1,x,mid);
                      build(id<<1|1,mid+1,y);
                      pushup(id);
                      }
                      int query (int id,int x,int y)
                      {
                      if (tree[id].l==x&&tree[id].r==y)
                      return tree[id].Max;
                      int mid=tree[id].mid();
                      if (y<=mid)
                      return query (id<<1,x,y);
                      else
                      if (mid+1<=x)
                      return query(id<<1|1,x,y);
                      else
                      return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                      }
                      void add (int id,int x,int num)
                      {
                      if (tree[id].l==tree[id].r&&tree[id].l==x)
                      {
                      tree[id].Max=num;
                      return;
                      }
                      int mid=tree[id].mid();
                      if (x<=mid)
                      add (id<<1,x,num);
                      else
                      add (id<<1|1,x,num);
                      pushup (id);
                      }
                      int main()
                      {
                      int t,n,m,op,a,b,i,j,k;
                      scanf ("%d",&t);
                      for (j=0;j<t;j++)
                      {
                      scanf ("%d",&n);
                      for (i=1;i<=n;i++)
                      scanf ("%d",&aa[i]);
                      build (1,1,n);
                      scanf ("%d",&m);
                      for (i=1;i<=m;i++)
                      {
                      scanf ("%d%d%d",&op,&a,&b);
                      if (op==1)
                      {
                      if (a<=b)
                      k=query (1,a,b);
                      else
                      k=max(query (1,a,n),query (1,1,b));
                      printf ("%d\n",k);
                      }
                      if (op==2)
                      add (1,a,b);
                      }
                      }
                      return 0;
                      }


                      IP属地:北京11楼2015-05-23 14:54
                      回复
                        #include <cstdio>
                        #include <cstring>
                        #include <algorithm>
                        #include <cstdlib>
                        #include <cmath>
                        using namespace std;
                        struct node
                        {
                        int l,r;
                        int Max;
                        int mid()
                        {
                        return (l+r)>>1;
                        }
                        }tree[4*100005];
                        int aa[100005];
                        void pushup (int id)
                        {
                        tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                        }
                        void build(int id,int x,int y)
                        {
                        tree[id].l=x;
                        tree[id].r=y;
                        if (x==y)
                        {
                        tree[id].Max=aa[x];
                        return;
                        }
                        int mid=tree[id].mid();
                        build(id<<1,x,mid);
                        build(id<<1|1,mid+1,y);
                        pushup(id);
                        }
                        int query (int id,int x,int y)
                        {
                        if (tree[id].l==x&&tree[id].r==y)
                        return tree[id].Max;
                        int mid=tree[id].mid();
                        if (y<=mid)
                        return query (id<<1,x,y);
                        else
                        if (mid+1<=x)
                        return query(id<<1|1,x,y);
                        else
                        return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                        }
                        void add (int id,int x,int num)
                        {
                        if (tree[id].l==tree[id].r&&tree[id].l==x)
                        {
                        tree[id].Max=num;
                        return;
                        }
                        int mid=tree[id].mid();
                        if (x<=mid)
                        add (id<<1,x,num);
                        else
                        add (id<<1|1,x,num);
                        pushup (id);
                        }
                        int main()
                        {
                        int t,n,m,op,a,b,i,j,k;
                        scanf ("%d",&t);
                        for (j=0;j<t;j++)
                        {
                        scanf ("%d",&n);
                        for (i=1;i<=n;i++)
                        scanf ("%d",&aa[i]);
                        build (1,1,n);
                        scanf ("%d",&m);
                        for (i=1;i<=m;i++)
                        {
                        scanf ("%d%d%d",&op,&a,&b);
                        if (op==1)
                        {
                        if (a<=b)
                        k=query (1,a,b);
                        else
                        k=max(query (1,a,n),query (1,1,b));
                        printf ("%d\n",k);
                        }
                        if (op==2)
                        add (1,a,b);
                        }
                        }
                        return 0;
                        }


                        IP属地:北京12楼2015-05-23 14:54
                        回复
                          #include <cstdio>
                          #include <cstring>
                          #include <algorithm>
                          #include <cstdlib>
                          #include <cmath>
                          using namespace std;
                          struct node
                          {
                          int l,r;
                          int Max;
                          int mid()
                          {
                          return (l+r)>>1;
                          }
                          }tree[4*100005];
                          int aa[100005];
                          void pushup (int id)
                          {
                          tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                          }
                          void build(int id,int x,int y)
                          {
                          tree[id].l=x;
                          tree[id].r=y;
                          if (x==y)
                          {
                          tree[id].Max=aa[x];
                          return;
                          }
                          int mid=tree[id].mid();
                          build(id<<1,x,mid);
                          build(id<<1|1,mid+1,y);
                          pushup(id);
                          }
                          int query (int id,int x,int y)
                          {
                          if (tree[id].l==x&&tree[id].r==y)
                          return tree[id].Max;
                          int mid=tree[id].mid();
                          if (y<=mid)
                          return query (id<<1,x,y);
                          else
                          if (mid+1<=x)
                          return query(id<<1|1,x,y);
                          else
                          return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                          }
                          void add (int id,int x,int num)
                          {
                          if (tree[id].l==tree[id].r&&tree[id].l==x)
                          {
                          tree[id].Max=num;
                          return;
                          }
                          int mid=tree[id].mid();
                          if (x<=mid)
                          add (id<<1,x,num);
                          else
                          add (id<<1|1,x,num);
                          pushup (id);
                          }
                          int main()
                          {
                          int t,n,m,op,a,b,i,j,k;
                          scanf ("%d",&t);
                          for (j=0;j<t;j++)
                          {
                          scanf ("%d",&n);
                          for (i=1;i<=n;i++)
                          scanf ("%d",&aa[i]);
                          build (1,1,n);
                          scanf ("%d",&m);
                          for (i=1;i<=m;i++)
                          {
                          scanf ("%d%d%d",&op,&a,&b);
                          if (op==1)
                          {
                          if (a<=b)
                          k=query (1,a,b);
                          else
                          k=max(query (1,a,n),query (1,1,b));
                          printf ("%d\n",k);
                          }
                          if (op==2)
                          add (1,a,b);
                          }
                          }
                          return 0;
                          }


                          IP属地:北京13楼2015-05-23 14:54
                          回复
                            #include <cstdio>
                            #include <cstring>
                            #include <algorithm>
                            #include <cstdlib>
                            #include <cmath>
                            using namespace std;
                            struct node
                            {
                            int l,r;
                            int Max;
                            int mid()
                            {
                            return (l+r)>>1;
                            }
                            }tree[4*100005];
                            int aa[100005];
                            void pushup (int id)
                            {
                            tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                            }
                            void build(int id,int x,int y)
                            {
                            tree[id].l=x;
                            tree[id].r=y;
                            if (x==y)
                            {
                            tree[id].Max=aa[x];
                            return;
                            }
                            int mid=tree[id].mid();
                            build(id<<1,x,mid);
                            build(id<<1|1,mid+1,y);
                            pushup(id);
                            }
                            int query (int id,int x,int y)
                            {
                            if (tree[id].l==x&&tree[id].r==y)
                            return tree[id].Max;
                            int mid=tree[id].mid();
                            if (y<=mid)
                            return query (id<<1,x,y);
                            else
                            if (mid+1<=x)
                            return query(id<<1|1,x,y);
                            else
                            return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                            }
                            void add (int id,int x,int num)
                            {
                            if (tree[id].l==tree[id].r&&tree[id].l==x)
                            {
                            tree[id].Max=num;
                            return;
                            }
                            int mid=tree[id].mid();
                            if (x<=mid)
                            add (id<<1,x,num);
                            else
                            add (id<<1|1,x,num);
                            pushup (id);
                            }
                            int main()
                            {
                            int t,n,m,op,a,b,i,j,k;
                            scanf ("%d",&t);
                            for (j=0;j<t;j++)
                            {
                            scanf ("%d",&n);
                            for (i=1;i<=n;i++)
                            scanf ("%d",&aa[i]);
                            build (1,1,n);
                            scanf ("%d",&m);
                            for (i=1;i<=m;i++)
                            {
                            scanf ("%d%d%d",&op,&a,&b);
                            if (op==1)
                            {
                            if (a<=b)
                            k=query (1,a,b);
                            else
                            k=max(query (1,a,n),query (1,1,b));
                            printf ("%d\n",k);
                            }
                            if (op==2)
                            add (1,a,b);
                            }
                            }
                            return 0;
                            }


                            IP属地:北京14楼2015-05-23 14:54
                            回复
                              2025-12-26 23:41:48
                              广告
                              不感兴趣
                              开通SVIP免广告
                              #include <cstdio>
                              #include <cstring>
                              #include <algorithm>
                              #include <cstdlib>
                              #include <cmath>
                              using namespace std;
                              struct node
                              {
                              int l,r;
                              int Max;
                              int mid()
                              {
                              return (l+r)>>1;
                              }
                              }tree[4*100005];
                              int aa[100005];
                              void pushup (int id)
                              {
                              tree[id].Max=max(tree[id<<1].Max,tree[id<<1|1].Max);
                              }
                              void build(int id,int x,int y)
                              {
                              tree[id].l=x;
                              tree[id].r=y;
                              if (x==y)
                              {
                              tree[id].Max=aa[x];
                              return;
                              }
                              int mid=tree[id].mid();
                              build(id<<1,x,mid);
                              build(id<<1|1,mid+1,y);
                              pushup(id);
                              }
                              int query (int id,int x,int y)
                              {
                              if (tree[id].l==x&&tree[id].r==y)
                              return tree[id].Max;
                              int mid=tree[id].mid();
                              if (y<=mid)
                              return query (id<<1,x,y);
                              else
                              if (mid+1<=x)
                              return query(id<<1|1,x,y);
                              else
                              return max(query (id<<1,x,mid),query (id<<1|1,mid+1,y));
                              }
                              void add (int id,int x,int num)
                              {
                              if (tree[id].l==tree[id].r&&tree[id].l==x)
                              {
                              tree[id].Max=num;
                              return;
                              }
                              int mid=tree[id].mid();
                              if (x<=mid)
                              add (id<<1,x,num);
                              else
                              add (id<<1|1,x,num);
                              pushup (id);
                              }
                              int main()
                              {
                              int t,n,m,op,a,b,i,j,k;
                              scanf ("%d",&t);
                              for (j=0;j<t;j++)
                              {
                              scanf ("%d",&n);
                              for (i=1;i<=n;i++)
                              scanf ("%d",&aa[i]);
                              build (1,1,n);
                              scanf ("%d",&m);
                              for (i=1;i<=m;i++)
                              {
                              scanf ("%d%d%d",&op,&a,&b);
                              if (op==1)
                              {
                              if (a<=b)
                              k=query (1,a,b);
                              else
                              k=max(query (1,a,n),query (1,1,b));
                              printf ("%d\n",k);
                              }
                              if (op==2)
                              add (1,a,b);
                              }
                              }
                              return 0;
                              }


                              IP属地:北京15楼2015-05-23 14:55
                              回复