求序列第K大数 POJ2104

原创 2013年12月05日 18:41:59

在POJ2104中,由于会给定序列的区间,而且是多次查询,所以像快速排序加二分这种分治算法的时间效率就不算很高了,然后自己尝试用二叉搜索树保存数据,粗略的写了个java代码:

 

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

/**
 *
 * @author Sot_fzh
 */
public class Poj2104 {

    static class Point {

        int x;
        int left = -1;
        int right = -1;
    }
    static Point[] p;

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        int count = scan.nextInt();
        int[] a = new int[num];
        int[] b = new int[num];
        p = new Point[num];
        for (int i = 0; i < num; i++) {
            a[i] = b[i] = scan.nextInt();
        }
        Arrays.sort(b);
        for (int i = 0; i < num; i++) {
            p[i] = new Point();
            p[i].x = b[i];
        }
        int head = creTree(b, 0, num - 1);

        while (count-- != 0) {
            int low = scan.nextInt() - 1;
            int high = scan.nextInt() - 1;
            int k = scan.nextInt();
            int h = head;
            while (true) {
                int down = 0, up = 0;
                for (int i = low; i <= high; i++) {
                    if (a[i] < p[h].x) {
                        down++;
                    }
                    if (a[i] > p[h].x) {
                        up++;
                    }
                }

                if (down >= k) {            //证明在左子树
                    h = p[h].left;

                } else if (down < k) {                //证明不在左子树
                    if (down==k-1&&up+down+1==high-low+1) {        //如果大于中值点数+小于中值点的数+1==总共数
                        System.out.println(p[h].x);
                        break;
                    }

                    h = p[h].right;
                }
                                  
            }


        }

 


    }

    public static int creTree(int[] b, int low, int high) {
        int mid = (low + high) / 2;
        if (low <= mid - 1) {
            p[mid].left = creTree(b, low, mid - 1);
        }
        if (high >= mid + 1) {
            p[mid].right = creTree(b, mid + 1, high);
        }
        return mid;
    }

    public static void printP(int head) {               //先序遍历
        System.out.print(p[head].x + " ");                
        if (p[head].left != -1) {
            printP(p[head].left);
        }
        if (p[head].right != -1) {
            printP(p[head].right);
        }
    }

    public static void printM(int head) {            //中序遍历
        if (p[head].left != -1) {
            printM(p[head].left);
        }
        System.out.print(p[head].x + " ");
        if (p[head].right != -1) {
            printM(p[head].right);
        }

    }
}

 

由于自己长期怕麻烦又习惯使用java编写程序,经典的树形数据结构其实自己还很少用代码来实现,以上代码又是tle。。

 

但是无意中发现这道题目可以这样做:

设置节点,保存序列时把每个数的原始下标也保存下来,然后进行排序,之后从小到大依次检验节点的下标是否在给定区间中,若存在k--,否则下一个,当k减到0时,证明Kth已经找到。这里根据节点保存的原始下标来检验是否包含在给定区间中,这一点比较巧妙,因为用一个比较大小来代替一个for循环了。

以下代码AC

 

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

/**
 *
 * @author Sot_fzh
 */
public class My2104 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int len = scan.nextInt();
        int num = scan.nextInt();
        Point[] pa = new Point[len];

        for (int i = 0; i < len; i++) {
            pa[i] = new Point(i, scan.nextInt());
        }
        Arrays.sort(pa);

        while (num-- != 0) {
            int left = scan.nextInt() - 1;
            int right = scan.nextInt() - 1;
            int k = scan.nextInt();
            for (int i = 0; i < len; i++) {             //从小到达遍历排序数组
                if (pa[i].i >= left && pa[i].i <= right) {
                    k--;
                }

                if (k == 0) {
                    System.out.println(pa[i].num);
                    break;
                }

            }
        }
    }

    static class Point implements Comparable{

        int i, num;
        public Point(int i, int num) {
            this.i = i;
            this.num = num;
        }
        @Override
        public int compareTo(Object o) {
            return num-((Point)o).num;
        }
    }
}

相关文章推荐

POJ2104-K-th Number-求区间第K大数(暴力or归并树or划分树)

题目链接:http://poj.org/problem?id=2104 题目意思很简单,就是给你一个序列,查询某区间第K大的数; 方法1:时间复杂度O(N*M);不支持更新操作,代码简单; 利用...
  • wlxsq
  • wlxsq
  • 2015年08月10日 21:01
  • 590

区间第K大数——划分树(POJ2104解题报告)

百度百科:划分树是一种基于线段树的数据结构。主要用于快速求出(在log(n)的时间复杂度内)序列区间的第k大值。 划分树的基本思想就是对于某个区间,把它划分成两个子区间,左边区间的数小于右边区间的数...

POJ 2104 K-th Number&&HDU 2665 Kth number划分树 求区间第k大 裸题

K-th Number Time Limit: 20000MS   Memory Limit: 65536K Total Submissions: 46800   Accepted: 15...

poj 2104 (求区间第K大元素)

//为了做一道题,以前不知道什么划分树,只能从最基本的学,这是入门题,看了别人了代码,然后慢慢写的#include using namespace std ; const int MAXN = ...

【归并树—求第K小数】POJ 2104/HDU 2665

归并树 O(logn*logn*logn) for each query,很慢的说,划分树版http://blog.csdn.net/leolin_/article/details/6696801 ...
  • leolin_
  • leolin_
  • 2012年02月15日 11:40
  • 564

poj 2104(划分树 求第k大的数)

//用的是书上的模板#include #include #include #include using namespace std; const int maxn=100010; int tr...
  • mtxxxx
  • mtxxxx
  • 2016年09月07日 09:41
  • 107

POJ 2104-K-th Number(划分树)求区间内第k小的数

K-th Number Time Limit: 20000MS   Memory Limit: 65536K Total Submissions: 46178   Accepted: 1...
  • MIKASA3
  • MIKASA3
  • 2016年04月15日 11:42
  • 623

POJ 2104 K-th Number 主席树(求区间第k大)

点击打开链接 主席书资料 题意:给出n个数,m次询问,[x,y]内第k小的数时多少?n 主席树:对原序列的每个前缀i都建立一个线段树 维护值域[l,r]中的每个数,在前缀i的出现次数. ...

pku2104 第k大数-划分树做法

http://poj.org/problem?id=2104 题意:求任意区间第k大数   分析:划分树主要参考了大牛博客 http://www.notonlysuccess.com/?p=142 h...

POJ2104 K-th Number 划分树求区间第K大数

Problem Address:http://poj.org/problem?id=2104【前言】如果是多次查询数组任意区间的最值,那么线段树或者树状数组都可以,后者更易实现。但是如果是多次查询数组...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:求序列第K大数 POJ2104
举报原因:
原因补充:

(最多只允许输入30个字)