Frequent Values-线段树求解出现最多的数

Frequent Values(poj 3368)

注意：以下答案为离线作答结果，并非能通过poj，若要通过poj，需要修改函数接口，因为以下程序接受半封闭区间(s,e]，同时还需要修改输入数据的顺序

求出现最多的数：
给定n个数，已按从大到小顺序排列好，一共有q个询问，每次询问一个区间，问这个区间中出现次数最多的数是什么。
题目数据范围：
数的个数，1 ≤ n ≤ 100000
询问次数，1 ≤ q ≤ 100000
每个数的大小，-100000 ≤ ai ≤ 100000

思路：

使用线段树解决。因个数比较多，最多有10w个数据，又因为输入是有序的，从大到小输入。因此可以将相同数据保存到同一个结构体中，并记录一共有多少个相同的元素。这样做既可以免去合并子树求解出现最多数的麻烦，也节约了空间，提高了效率。

题目中使用数组来模拟线段树。

 /**********************************************************
  作者：SunboyL
  题目3：Frequent Values(poj 3368)

  求出现最多的数：
  给定n个数，已按从大到小顺序排列好，一共有q个询问，每次询问一个区间，问这个区间中出现次数最多的数是什么。
  题目数据范围：
  数的个数，1 ≤ n ≤ 100000
  询问次数，1 ≤ q ≤ 100000
  每个数的大小，-100000 ≤ ai ≤ 100000

  思路：很容易想到建立线段树，并在线段树的每个结点中保存区间中出现次数最多的数。
  需要解决的问题，两个子结点的信息如何合并到父结点。
  很显然，子结点中出现次数最多的数不一定就是父结点中出现次数最多的数

  时间：2013.10.28
 **********************************************************/

 #include <vector>
 #include <algorithm>
 #define MAXN (100000)

 typedef struct _dataSet
 {// 一个值相同的数据集合
     int value,count,lastNumSeq; //value表示一个值；count表示有多少个value值，seq表示在线性表中该集合最后一个值的序号
     int setSeq;// 集合序号，表示第几个集合
 }DataSet;

 typedef struct _segTree
 {
     int s,e; // 表示区段[s,e)
     DataSet mostValue; // mostValue表示区段[s,e)中出现最多的值.
 }SegTree,*pSegTree;

 void buildSegTree(pSegTree tree,int start,int end,int node)
 { // tree为树根节点，start到end区间为[start,end)，node表示节点编号
     tree[node].s = start;
     tree[node].e = end;
     tree[node].mostValue.value = 0x80000000;//0x80000000为最小的32位整数
     if(start +  == end)
         return;
     int mid = (start + end) >> ;
     buildSegTree(tree,start,mid,node*); // 建立左子树
     buildSegTree(tree,mid,end,node*+); // 建立右子树
 }

 void insertDataSet(pSegTree segTree,const DataSet& dataSet,int node = )
 {// 将dataSet插入到segTree中，node默认指向根节点，调用时忽略此参数
     if(dataSet.count > segTree[node].mostValue.count)
         segTree[node].mostValue = dataSet;// 每个节点都记录区间中出现次数最多的数
     if(segTree[node].s +  == segTree[node].e)
         return;// 叶子节点
     int mid = (segTree[node].s + segTree[node].e) / ;
     if(dataSet.setSeq < mid) // 线段树以集合的个数来划分线段，因此使用集合所在的序号判断插入到左子树或是右子树
         insertDataSet(segTree,dataSet,node*);
     else
         insertDataSet(segTree,dataSet,node*+);
 }

 DataSet query(pSegTree tree,const std::vector<DataSet>& dataSet,int l,int r,int node = )
 {// 查询在线性列表dataSet[]中(l,r]区间出现次数最多的数，并返回该数的相同元素集合
     DataSet result;
     int mid = (tree[node].s + tree[node].e) / ;
     int ds,de; // 将以集合为单位的区间转换为以单个数据值为单位的区间[ds,de)
     if(tree[node].s == )
         ds = ;
     else
         ds = dataSet[tree[node].s - ].lastNumSeq + ;
     de = dataSet[tree[node].e - ].lastNumSeq + ; // 因为std::vector<DataSet>& dataSet数组从0开始，所以相对起始位置，应该是减2

     if(l == ds && r == de)
     {
         return tree[node].mostValue;
     }
     if(tree[node].s +  == tree[node].e)
     {
         result = tree[node].mostValue;
         result.count = r - l;// 区间并不完全覆盖相同元素的集合，则相同的个数为其部分覆盖的个数。
         return result;
     }
     DataSet a,b;
     a.count = b.count = ;
     if(l <= dataSet[mid - ].lastNumSeq)
         a = query(tree,dataSet,l,std::min(r,dataSet[mid - ].lastNumSeq + ),node*);
     if(r > dataSet[mid - ].lastNumSeq + )
         b = query(tree,dataSet,std::max(l,dataSet[mid - ].lastNumSeq + ),r,node*+);
     result = a.count>b.count?a:b;
     return result;
 }

 void frequentValues()
 {// frequentValues函数是本程序接口。负责输入。
     int n,i; // n:有多少个要输入的元素
     std::vector<DataSet> dataSet; // 本题目主要研究线段树而非线性表，这里就使用一下容器偷懒
     DataSet temp;

     std::cin >> n; // 输入一共有多少个数据
     if(n <  || n > MAXN) // 元素个数为1到100000
         return;

     std::cin >> temp.value;// 输入第一个元素的值
     temp.count = ;
     temp.lastNumSeq = ;
     temp.setSeq = ;// 第一个集合
     dataSet.push_back(temp);
     int q = ; // 指向dataSet数组中当前值（集合）的指针

     for( i = ;i <= n;++i )
     {
         std::cin >> temp.value;
         if(temp.value == dataSet[q].value)
         {
             dataSet[q].count ++;
             dataSet[q].lastNumSeq ++;
         }
         else
         {
             temp.count = ; // 值不相同，表示另外一个集合，充值value值有一个，序号为前一个集合的最后一个值的序号加一
             temp.lastNumSeq = dataSet[q].lastNumSeq + ;
             temp.setSeq = dataSet[q++].setSeq + ;
             dataSet.push_back(temp);
         }
     }
     int size = dataSet.size(); // 记录值不同的集合有多少个，并利用这个，建立1-size的线段树
     pSegTree segTree = new SegTree[*size];

     buildSegTree(segTree,,size+,); // 以segTree为根节点，集合个数size（1-size+1）为线段区间建立线段树
     for(i = ;i < size;++i)
         insertDataSet(segTree,dataSet[i]);// 将dataSet中的数据集合插入到线段树中

     int ask; // 多少次询问
     std::cin >> ask;
     while(ask --)
     {
         DataSet result;
         int l,r;
         std::cin >> l >> r;// 输入要询问的区间[l,r)
         result = query(segTree,dataSet,l,r);
         int t = result.value;
         std::cout << t << std::endl;
     }
     delete[] segTree;

 }

 #include <iostream>
 #include <list>
 using namespace std;
 int main()
 {
     //MergeSortTest(); // 测试题目一，归并排序
     //movableWindowsTest();// 测试题目二，移动窗口，输出窗口中的最小值
     //MonkeyKingTest();// 测试题目三，猴王monkey king
     frequentValues(); // 测试题目四，Frequently Values

     return ;
 }

20

50 48 48 48 48 47 39 39 39 39 20 20 17 16 16 16 16 16 12 11
5
1 21
3 12
5 9
7 17
7 18

输出结果如下：