poj2299 QuickSort(线段树模板)

最新推荐文章于 2020-04-10 21:24:31 发布

原创最新推荐文章于 2020-04-10 21:24:31 发布 · 217 阅读

0 ·

CC 4.0 BY-SA版权

算法_线段树专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了一种高效的数据结构——线段树，在解决特定类型问题中的应用。通过实例讲解了线段树的构建、查询和更新操作，并提供了一个完整的Java实现示例，帮助读者深入理解线段树的工作原理及其在大规模数据集上的优势。

题目链接： http://poj.org/problem?id=2299

解题方式：线段树 或者归并排序或者树状数组

线段树基础：https://blog.youkuaiyun.com/zearot/article/details/52280189

线段树详解： https://blog.youkuaiyun.com/zearot/article/details/48299459 感谢作者

线段树和树状数组本题应用的方式是一样的：通过灭灯的方式，去统计，比如说样例

9 1 0 5 4 , 比如初始每盏灯都亮着，就是1 1 1 1 1 ，从小到大灭灯，先灭掉数字 0，得到灯的状态 1 1 0 1 1 ，所以发现前面有2盏灯亮着，所以rs +=2 ; 接着灭掉数字 1，灯的状态是 1 0 0 1 1 , 所以 rs+=1; 依次灭掉所有的灯，得到结果就是rs.

这里涉及到更新和统计，而且数据规模有50万，所以要时间复杂度要低，所以可以用线段树或者树状数组。

线段树模板:

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
   static final int maxn = 500000+1;
   static long sum[] = new long [2<<20];//存放树结构
   static long A[] = new long [maxn];//原数组
   static long query(int L,int R,int l,int r,int rt) //查询
   {
       if(l>=L && r<=R){
           return sum[rt];
       }
       int ANS = 0;
       int mid = (l+r)/2;
       if(mid>=L) ANS += query(L,R,l,mid,rt<<1);
       if(R>=mid+1) ANS += query(L,R,mid+1,r,rt<<1|1);
       return ANS;
   }
   static void pushUp(int id){
       sum[id] = sum[id<<1] + sum[id<<1|1];
   }
   static void build(int l,int r,int rt)//建树
   {
       if(l==r) {
           sum[rt] = A[l];
           return ;
       }
       int mid = (l+r)/2;
       build(l,mid,rt<<1);
       build(mid+1,r,rt<<1|1);
       pushUp(rt);
   }
   static void update(int L,int C,int l,int r,int rt) //更新节点L
   {
       if(l==r){
           sum[rt] += C;
           return ;
       }
       int mid = (l+r)/2;
       if(L<=mid && L>=l) update(L,C,l,mid,rt<<1);
       if(L>=mid+1 && L<=r) update(L,C,mid+1,r,rt<<1|1);
       pushUp(rt);
   }
   static class Node
   {
       int pos,val;
       Node(int pp,int vv){
           pos = pp ; val = vv;
       }
       Node(){}
   }
   public static void main(String[] args) {
       int n;
       Scanner sc = new Scanner(System.in);
       Node nodeList[] = new Node[maxn];
       for(int i=0;i<maxn;i++){
           nodeList[i] = new Node();
       }
       class Cmp implements Comparator<Node>
       {
           @Override
           public int compare(Node o1, Node o2) {
               if(o1.val != o2.val){
                   return o1.val - o2.val;
               }else{
                   return o1.pos - o2.pos;
               }
           }
       }
       while(true){
           n = sc.nextInt();
           if(n==0) break;
           for(int i=0;i<n;i++){
               A[i+1] = sc.nextInt();
               nodeList[i].pos = i+1;
               nodeList[i].val = (int)A[i+1];
               A[i+1] = 1;
           }
           Arrays.sort(nodeList,0,n,new Cmp());
           build(1,n,1);
           long rs = 0;
           for(int i=0;i<n;i++)
           {
               Node tmp = nodeList[i];
               int pos = tmp.pos;
               update(pos,-1,1,n,1);
               if(pos>1){
                   rs += query(1,pos-1,1,n,1);
               }
           }
           System.out.println(rs);
       }
   }
}