算法训练 Beaver's Calculator/codeforces 207A1 排序+贪心

问题描述　　从万能词典来的聪明的海狸已经使我们惊讶了一次。他开发了一种新的计算器，他将此命名为"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)mod mi。输出格式　　第一行输出一个整数，表示最优顺序下最少的“坏对”个数。
　　如果问题的总个数不超过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。
思路:首先对于每个科学家我们知道他们k个问题的相对顺序不能改变,所以对于每个科学家来说他们问题本身的顺序就有可能存在坏对,由于题目中所说对于同一个科学家的问题,只要求相对顺序不变,他们可以拆开插到别的科学家的问题之间.那么我们就可以设想,我们先分别记录每个科学家本身问题顺序的坏对的最大值,那么这个最大值是否可以作为问题的最后结果呢？答案是可以的，就按照以上提到的,我们可以将其余科学家的问题按照大小顺序穿插在那个本身坏对数最大的科学家的问题之中而不产生新的坏对数.我们可以对这些问题进行分层,对于每个科学家第一次出现坏对时（如果没有坏对就是整个序列）然后进行归并排序.（这里也可以选择其他稳定的排序方法,因为每个问题的相对顺序不能改变 所以只能选择稳定的排序）一直到第sum层。。。证明：首先对于每一个科学家自身的序列来说，由于我们用的是归并排序，所以绝对不会改变每一个科学家自身序列的相对顺序。其次对于每一层的序列，我们经过排序后肯定是保证严格递增的（即不存在坏对），对于下一层的序列来说同样如此，由于下一层的序列的问题中和上一层的序列的问题中至少存在着一个坏对，所以对于下一层的第一个数（也是最小的那个数）必定是小于上一层的最后一个数的，也就是说保证了2层之间有一个坏对数。那么最终答案就是sum个坏对数，也就是最少的坏对数。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
#define N 200010
using namespace std;
struct tc{
int cnt,count;//cnt下标 count 问题数量
ll p[5001];
}q[5001];
struct sc{
int id;//下标
ll num;//消耗
}anss
,s
;
void merge(int l,int mid,int r)//归并排序
{
int i=l,j=mid+1;
int cc=l;
while(i<=mid&&j<=r)
{
if(anss[i].num<=anss[j].num)
{
s[cc].id=anss[i].id;
s[cc++].num=anss[i++].num;
}
else
{
s[cc].id=anss[j].id;
s[cc++].num=anss[j++].num;
}
}
while(i<=mid)
{
s[cc].id=anss[i].id;
s[cc++].num=anss[i++].num;
}
while(j<=r)
{
s[cc].id=anss[j].id;
s[cc++].num=anss[j++].num;
}
for(i=l;i<cc;i++)
{
anss[i].id=s[i].id;
anss[i].num=s[i].num;
}
return ;
}
void mergesort(int x,int y)
{
if(x<y)
{
int mid=(x+y)/2;
mergesort(x,mid);
mergesort(mid+1,y);
merge(x,mid,y);
}
return ;
}
int main()
{
int i,j;
ll n,a,x,y,m;
int ans=-1,k,sum,l=0;
cin>>n;
for(i=0;i<n;i++)
{
scanf("%d %I64d %I64d %I64d %I64d",&k,&a,&x,&y,&m);
sum=0;
l+=k;
q[i].cnt=1;
q[i].count=k;
q[i].p[1]=a;
for(j=2;j<=k;j++)
{
q[i].p[j]=(x*q[i].p[j-1]+y)%m;
if(q[i].p[j]<q[i].p[j-1])
sum++;
}
ans=max(ans,sum);//找最大
}
printf("%d\n",ans);
int st=0,end=0;
if(l <= 2e5)
{
while(end<l)
{
for(i=0;i<n;i++)//分层归并排序
{
for(j=q[i].cnt;j<=q[i].count;j++)
{
if(j!=q[i].cnt&&q[i].p[j]<q[i].p[j-1])// 每一层的第一个j 不能和前一个比较
{ q[i].cnt=j;
break;
}
anss[end].id=i;
anss[end++].num=q[i].p[j];
}
if(j>q[i].count)//如果没有坏对就是整个序列
q[i].cnt=j;
}
mergesort(st,end-1);
st=end;
}
for(i=0;i<l;i++)
printf("%I64d %d\n",anss[i].num,anss[i].id+1);
}
return 0;
}


下面说一下对于这道题一个非常巧妙的方法,把两个方法放在一起.两个问题的思想完全一样 都是进行分层排序,我们上一个是采用的分层归并排序,这里思想非常巧妙！！！
利用结构体并且+快排直接分层排序#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
ll n,a,k,x,y,m,b;
struct node
{
int x,y,z;//x 表示层数 y 表示的是所需资源单位数 z表示的是科学家的编号
}p[200010];
int cmp(node w,node l)//这里非常巧妙！如果层数相等 在同一层里我们就按照所需资源单位数排序,如果资源单位数相同就按照科学家</pre><pre name="code" class="cpp">//编号排序,否则就按照层数排序
{
if(w.x==l.x)
return w.y<l.y||(w.y==l.y&&w.z<l.z);
return w.x<l.x;
}
int main()
{
int i,j;
int ans=-1,cnt=0;
cin>>n;
for(i=1;i<=n;i++)
{
int t=0;//t 计算为第几层,这里都一样我们还是按照坏对来分层出现一次为一层,没有坏对就是整个序列
scanf("%I64d %I64d %I64d %I64d %I64d",&k,&a,&x,&y,&m);
for(j=1;j<=k;j++)//这里是分层的关键！
{
if(cnt <= 2e5)
p[cnt++]=(node){t,a,i};
b=(x*a+y)%m;
if(b<a&&j!=k)//第k个问题没有最后一个b
t++;
a=b;
}
ans=max(ans,t);
}
printf("%d\n",ans);
if(cnt <= 2e5)
{
sort(p,p+cnt,cmp);
for(i=0;i<cnt;i++)
{
printf("%d %d\n",p[i].y,p[i].z);
}

}
return 0;
}