Running Median POJ - 3784 （对顶堆/优先队列 | 链表）

For this problem, you will write a program that reads in a sequence of 32-bit signed integers. After each odd-indexed value is read, output the median (middle value) of the elements received so far.

Input

The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. The first line of each data set contains the data set number, followed by a space, followed by an odd decimal integer M, (1 ≤ M ≤ 9999), giving the total number of signed integers to be processed. The remaining line(s) in the dataset consists of the values, 10 per line, separated by a single space. The last line in the dataset may contain less than 10 values.

Output

For each data set the first line of output contains the data set number, a single space and the number of medians output (which should be one-half the number of input values plus one). The output medians will be on the following lines, 10 per line separated by a single space. The last line may have less than 10 elements, but at least 1 element. There should be no blank lines in the output.

Sample Input

3
1 9
1 2 3 4 5 6 7 8 9
2 9
9 8 7 6 5 4 3 2 1
3 23
23 41 13 22 -3 24 -31 -11 -8 -7
3 5 103 211 -311 -45 -67 -73 -81 -99
-33 24 56

Sample Output

1 5
1 2 3 4 5
2 5
9 8 7 6 5
3 12
23 23 22 22 13 3 5 5 3 -3
-7 -3
 
题意：每组M个数，然后对于每组数读入的时候，只要读入了奇数个的数，就求出先前读入数的中位数，然后输出
 
思路：可以采用两个优先队列的做法，如果当前读入的数>当前中位数，插入小根堆，否则插入大根堆，这样实际上就维护了中位数相邻两侧的值。
然后维护 num【小根堆】 - num【大根堆】 <= 1，就是维护中位数两侧的数量应当均分，这样小根堆的top，即是中位数

 #include<cstdio>
 #include<iostream>
 #include<queue>
 using namespace std;
 
 int t;
 int cas,n;
 const int maxn = 1e4+;
 int ans[maxn];
 int main()
 {
     scanf("%d",&t);
     while(t--)
     {
 priority_queue<int,vector<int>,greater<int> >que1;
 priority_queue<int,vector<int>,less<int> >que2;
 
         scanf("%d%d",&cas,&n);
         printf("%d %d\n",cas,n/+);
         int tmp;
         int l=,r=,num=;
         int cnt = ;
         for(int i=;i<=n;i++)
         {
             scanf("%d",&tmp);
             if(tmp > num)
             {
                 que1.push(tmp);
                 r++;
             }
             else
             {
                 que2.push(tmp);
                 l++;
             }
             if(r < l)
             {
                 int f = que2.top();
                 que2.pop();
                 que1.push(f);
                 r++,l--;
             }
             else if(r > l + )
             {
                 r--,l++;
                 int f = que1.top();
                 que1.pop();
                 que2.push(f);
             }
             num = que1.top();
             if(i&)
             {
                 ans[++cnt] = num;
             }
         }
         for(int i=;i<=cnt;i++)
         {
             printf("%d",ans[i]);
             if(i != cnt && i%!=)printf(" ");
             else printf("\n");
         }
     }
 }

链表：
链表主要是个离线处理，先将所有的数据读入，然后记录下其下标。
然后对其排序，记录下在有序序列下，原来下标的数在哪出现。
然后从n~1进行处理，因为n永远是该序列剩余的数中最后出现的，也就是说不会将该数后未输入的数进行计算。
 
（关于中位数下标pos的移动那，按照写法是有问题的，但是这题上适用）

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
 
int t;
int cas,n;
const int maxn = 1e4+;
struct Node
{
    int val;
    int next;
    int pre;
    int index;
}node[maxn];
int p[maxn];
 
bool cmp(Node a,Node b)
{
    return a.val < b.val;
}
int ans[maxn];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&cas,&n);
        printf("%d %d\n",cas,(n+)>>);
        for(int i=;i<=n;i++)
        {
            scanf("%d",&node[i].val);
            node[i].index = i;
        }
        sort(node+,node++n,cmp);
        for(int i=;i<=n;i++)
        {
            node[i].next = i+;
            node[i].pre = i-;
        }
        node[].pre = node[n].next = -;
        for(int i=;i<=n;i++)
        {
            p[node[i].index] = i;
        }
        int pos = (n+)>>;
        int tot = ;
        int l=,r=;
        for(int i=n;i>;i--)
        {
 
            if(i & )
            {
                if(l  > r)pos = node[pos].next;
                else if(l < r)pos = node[pos].pre;
                ans[++tot] = node[pos].val;
                l=r=;
            }
            if(p[i] >= pos)r++;
            if(p[i] <= pos)l++;
            if(node[p[i]].pre != -)
            {
                node[node[p[i]].pre].next = node[p[i]].next;
            }
            if(node[p[i]].next != -)
            {
                node[node[p[i]].next].pre = node[p[i]].pre;
            }
        }
        for(int i=;i<=tot;i++)
        {
            printf("%d",ans[tot-i+]);
            if(i% !=  && i != tot)printf(" ");
            else printf("\n");
        }
    }
}