Beaver's Calculator(归并排序+贪心)

问题描述

　　从万能词典来的聪明的海狸已经使我们惊讶了一次。他开发了一种新的计算器，他将此命名为"Beaver's Calculator 1.0"。它非常特别，并且被计划使用在各种各样的科学问题中。
　　为了测试它，聪明的海狸邀请了n位科学家，编号从1到n。第i位科学家给这个计算器带来了 ki个计算题。第i个科学家带来的问题编号1到n，并且它们必须按照编号一个一个计算，因为对于每个问题的计算都必须依赖前一个问题的计算结果。
　　每个教授的每个问题都用一个数 ai, j  来描述，i（1≤i≤n）是科学家的编号，j（1≤j≤ ki ）是问题的编号， ai, j  表示解决这个问题所需资源单位的数量。
　　这个计算器非常不凡。它一个接一个的解决问题。在一个问题解决后，并且在下一个问题被计算前，计算器分配或解放资源。
　　计算器中最昂贵的操作是解放资源，解放远远慢于分配。所以对计算器而言，每一个接下来的问题所需的资源不少于前一个，是非常重要的。
　　给你关于这些科学家所给问题的相关信息。你需要给这些问题安排一个顺序，使得“坏对”尽可能少。
　　所谓“坏对”，就是相邻两个问题中，后一个问题需求的资源比前一个问题少。别忘了，对于同一个科学家给出的问题，计算它们的相对顺序必须是固定的。

输入格式

　　第一行包含一个整数n，表示科学家的人数。接下来n行每行有5个整数，ki, ai, 1, xi, yi, mi (0 ≤ ai, 1 < mi ≤ 109, 1 ≤ xi, yi ≤ 109) ，分别表示第i个科学家的问题个数，第1个问题所需资源单位数，以及3个用来计算 ai, j 的参量。ai, j = (ai, j - 1 * xi + yi)modmi。

输出格式

　　第一行输出一个整数，表示最优顺序下最少的“坏对”个数。
　　如果问题的总个数不超过200000,接下来输出  行，表示解决问题的最优顺序。每一行两个用空格隔开的整数，表示这个问题所需的资源单位数和提供这个问题的科学家的编号。

样例输入

2
2 1 1 1 10
2 3 1 1 10

样例输出

0
1 1
2 1
3 2
4 2

数据规模和约定

　　20%的数据 n = 2, 1 ≤ ki ≤ 2000；
　　另外30%的数据 n = 2, 1 ≤ ki ≤ 200000；
　　剩下50%的数据 1 ≤ n ≤ 5000, 1 ≤ ki ≤ 5000。

题目要求大体上就是把所有科学家的问题按照所需资源数目从小到大的顺序排序，但是同一科学家的问题资源排列相对顺序不能改变，并且保证“坏对”尽量少。输出所谓的最小“坏对数”，接下来的行是题目要求的最优顺序。

思路：将所有科学家的问题按照所需资源数目从小到大的顺序排序，采用归并排序，因为稳定且复杂度低（同一科学家的问题相对顺序不能改变）。排序可使不同科学家的问题序列合并时不产生“坏对”，但同一科学家问题序列产生的“坏对”不可避免（因为前大后小，且相对顺序不能改变），因此“坏对”最多的科学家的坏对数即最优序列的坏对数。接下来分层次归并排序，各层结果排成序列，即最优序列。所谓分层，即从每个科学家的问题序列中取出到当前第一个坏对处的子序列，归并排序后放入结果序列，再各选截断点到下一个坏对处的子序列，归并排序后放入后序结果序列，依次执行直到所有问题放入结果序列。然后按要求输出。

#include <bits/stdc++.h>
using namespace std;
#define MAX 5005
typedef long long LL;
struct node
{
    int pos,counts; //每个科学家所提问题的结构体，用于分层
    LL nums[MAX];
} zy[MAX];
struct mge
{
    LL num,no;//所需资源数和科学家编号
} ans[MAX*40],tmp[MAX*40];
void Merge(int left,int right)
{
    int mid = (left+right)/2;
    int i = left,j = mid+1;
    int k = left;
    while(i<=mid&&j<=right)
    {
        if(ans[i].num<=ans[j].num)
        {
            tmp[k].no=ans[i].no;
            tmp[k++].num=ans[i++].num;
        }
        else
        {
            tmp[k].no=ans[j].no;
            tmp[k++].num=ans[j++].num;
        }
    }
    while(i<=mid)
    {
        tmp[k].no=ans[i].no;
        tmp[k++].num=ans[i++].num;
    }
    while(j<=right)
    {
        tmp[k].no=ans[j].no;
        tmp[k++].num=ans[j++].num;
    }
    for(int u=left; u<=right; u++)
    {
        ans[u]=tmp[u];
    }
}
void mergesort(int left,int right)
{
    if(left<right)
    {
        int mid = (left+right)/2;
        mergesort(left,mid);
        mergesort(mid+1,right);
        Merge(left,right);
    }
}
int main()
{
    int n,tol=0,bad=0,sum;
    int i,j;
    LL k,a,m,x,y;
    cin>>n;
    for(i=1; i<=n; i++)
    {
        sum=0;
        cin>>k>>a>>x>>y>>m;
        tol+=k;
        zy[i].pos=1;
        zy[i].counts=k;
        zy[i].nums[1]=a;
        for(j=2; j<=k; j++)
        {
            zy[i].nums[j]=(zy[i].nums[j-1]*x+y)%m;
            if(zy[i].nums[j]<zy[i].nums[j-1])//坏对
                sum++;
        }
        bad=max(sum,bad);
    }
    cout<<bad<<endl;
    int loc;
    if(tol<=200000)
    {
        int left=1,right=1;
        while(right<=tol)
        {
            for(i=1; i<=n; i++)
            {
                loc=zy[i].counts+1;
                for(j=zy[i].pos; j<=zy[i].counts; j++)
                {
                    if(zy[i].nums[j]<zy[i].nums[j-1]&&j!=zy[i].pos)
                    {
                        loc=j;
                        break;//遇到"坏对",截断当前序列
                    }
                    ans[right].no=i;
                    ans[right++].num=zy[i].nums[j];
                }
                zy[i].pos=loc;
            }
            mergesort(left,right-1);//当前 一层归并排序
            left=right;
        }
        for(i=1; i<=tol; i++)
            cout<<ans[i].num<<" "<<ans[i].no<<endl;
    }
    return 0;
}