蓝桥杯 算法训练 Beaver's Calculator

蓝桥杯 算法训练 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)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。
#下面是我在网上找的正确代码，提交后100分

#include<iostream>
using namespace std;
#define N 200010
struct t{
	int nx,count;
	long long p[5001];
}q[5001];
struct s{
	int id;
	long long key;
}R[N],R1[N];
int max(int a,int b)
{
	return a>b?a:b;
}
void Merge(int s,int m,int t)		//设两个有序子表R[s]...R[m]和R[m+1]...R[t],将
{			
	int i,j,k;						//两个有序子表合并为一个新的有序表R1[s]...R1[t]
	i=s;
	j=m+1;
	k=s;
 
	while(i<=m && j<=t)
	{
		if(R1[i].key<R1[j].key)
		{
			R[k++]=R1[i++];
		}
		else
		{
			R[k++]=R1[j++];
		}
	}
	while(i<=m) R[k++]=R1[i++];
	while(j<=t) R[k++]=R1[j++];
	for(i=s;i<k;i++)
		R1[i]=R[i];
}
void MSort(int s,int t)
{
	if(s<t)
	{
		int m=(s+t)/2;
		MSort(s,m);
		MSort(m+1,t);
		Merge(s,m,t);
	}
}
int main()
{
	int i,j,n,k,r,x,y,m;
	int ls=0,ans=-1;
	int st=0,ed=0;
	cin>>n;
	for(i=0;i<n;i++)
	{
		cin>>k>>r>>x>>y>>m;
		int sum=0;
		ls+=k;
		q[i].nx=1;
		q[i].count=k;
		q[i].p[1]=r;
		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);
	}
 
	cout<<ans<<endl;
	if(ls<=200000)
	{
		while(ed<ls)
		{
			for(i=0;i<n;i++)
			{
				for(j=q[i].nx;j<=q[i].count;j++)
				{
					if(j!=q[i].nx&&q[i].p[j]<q[i].p[j-1])
					{
						q[i].nx=j;
						break;
					}
					R1[ed].id=i;
					R1[ed++].key=q[i].p[j];
				}
				if(j>q[i].count)
					q[i].nx=j;
			}
			MSort(st,ed-1);
			st=ed;
		}
		for(i=0;i<ls;i++)
		{
			cout<<R1[i].key<<" "<<R1[i].id+1<<endl;
		}
	}
	return 0;
}

#此处是我自己写的代码

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#define MAX_N 10005
using namespace std;   
int cost[MAX_N][MAX_N];

struct ques{ 
	int time;  
	int from;  
}; 
int k=0;
bool comp(ques &A,ques &B)
{
	return A.time<B.time;
}
int main()
{
	int count=0,sum=0;
	int n;
	cin>>n;
	int node[n];       
	int code[n][5];   
	for(int i=0;i<n;i++)  
	{
		cin>>code[i][0]>>code[i][1]>>code[i][2]>>code[i][3]>>code[i][4];
		node[i]=0;
	}
	
	for(int i=0;i<n;i++)
	{
		cost[i][0]=code[i][1];
		for(int j=1;j<code[i][0];j++)
		cost[i][j]=(cost[i][j-1]*code[i][2]+code[i][3])%code[i][4];
		
		count=0;
		for(int j=1;j<code[i][0];j++)
		{
			if(cost[i][j]<cost[i][j-1])
			count++;
		 } 
		sum=max(sum,count);
	 } 
	 cout<<sum<<endl;
	  
	for(int i=0;i<sum+1;i++)   
	{
		ques Q[MAX_N];        
		int m=0;
		for(int j=0;j<n;j++)  
		{
			if(node[j]<code[j][0])
			{
				Q[m].time=cost[j][node[j]];
			    Q[m].from=j;
				m++;
				node[j]++;
				for(int k=node[j];k<code[j][0];k++)  
				{
					if(cost[j][k]>=cost[j][k-1])
					{
						Q[m].time=cost[j][node[j]];
			            Q[m].from=j;
				        m++;
				        node[j]++;
		            }
					else						
					break;
				} 
			}
		}
		sort(Q,Q+m,comp); 
	    for(int j=0;j<m;j++)
	    {
	    	cout<<Q[j].time<<" "<<Q[j].from+1;
	    	cout<<endl;
		}
	 } 
	return 0;
}

我把两组代码的运行结果对比了一下，输了好多数据结果都是一样的，但是一直是0分，我不知道是为什么，求对这题有经验的朋友分享一下。