NOIP2016普及组T3海港解题报告

题目背景

NOIP2016 普及组 T3

题目描述

小 K 是一个海港的海关工作人员，每天都有许多船只到达海港，船上通常有很多来自不同国家的乘客。

小 K 对这些到达海港的船只非常感兴趣，他按照时间记录下了到达海港的每一艘船只情况；对于第 i 艘到达的船，他记录了这艘船到达的时间 t_i（单位：秒），船上的乘客数量 k_i ，以及每名乘客的国籍 x_i,1，x_i,2，...，x_i,ki 。

小 K 统计了 n 艘船的信息，希望你帮忙计算出以每一艘船到达时间为止的 24 小时（24小时=86400秒）内所有乘船到达的乘客来自多少个不同的国家。

形式化地讲，你需要计算 n 条信息。对于输出的第 i 条信息，你需要统计满足 t_i-86400＜t_p＜t_i的船只 p ，在所有的 x_p,j中，总共有多少个不同的数。

输入格式

第一行输入一个正整数 n ，表示小 K 统计了 n 艘船的信息。

接下来 n 行，每行描述一艘船的信息：前两个整数 ti 和 ki 分别表示这艘船到达海港的时间和船上的乘客数量，接下来 k_i 个整数 x_i,j 表示船上乘客的国籍。

保证输入的 t_i 是递增的，单位是秒；表示从小 K 第一次上班开始计时，这艘船在第 t_i秒到达海港。

保证 1≤n≤105，k_i≥1 ，∑k_i≤3×105 ， 1≤x_i,j≤105 ，1≤t_i-1＜t_i≤109 。

其中 ∑k_i表示所有的 k_i的和，∑k_i= k₁ + k₂ + ... + k_n。

输出格式

输出 n 行，第 i 行输出一个整数表示第 i 艘船到达后的统计信息。

样例数据 1

输入　 [复制]

3
1 4 4 1 2 2
2 2 2 3
10 1 3

输出

3
4
4

样例数据 2

输入　 [复制]

4
1 4 1 2 2 3
3 2 2 3
86401 2 3 4
86402 1 5

输出

3
3
3
4

备注

第一艘船在第 1 秒到达海港，最近 24 小时到达的船是第一艘船，共有 4 个乘客，分别是来自国家 4，1，2，2 ，共来自 3 个不同的国家；

第二艘船在第 2 秒到达海港，最近 24 小时到达的船是第一艘船和第二艘船，共有 4 + 2 = 6 个乘客，分别是来自国家 4，1，2，2，2，3 ，共来自 4 个不同的国家；

第三艘船在第 10 秒到达海港，最近 24 小时到达的船是第一艘船、第二艘船和第三艘船，共有 4 + 2 + 1 = 7 个乘客，分别是来自国家 4，1，2，2，2，3，3 ，共来自 4 个不同的国家。

【样例2说明】
第一艘船在第 1 秒到达海港，最近 24 小时到达的船是第一艘船，共有 4 个乘客，分别是来自国家 1，2，2，3 ，共来自 3 个不同的国家；

第二艘船在第 3 秒到达海港，最近 24 小时到达的船是第一艘船和第二艘船，共有 4 + 2 = 6 个乘客，分别是来自国家 1，2，2，3，2，3 ，共来自 3 个不同的国家；

第三艘船在第 86401 秒到达海港，最近 24 小时到达的船是第二艘船和第三艘船，共有 2 + 2 = 4 个乘客，分别是来自国家 2，3，3，4 ，共来自 3 个不同的国家；

第四艘船在第 86402 秒到达海港，最近 24 小时到达的船是第二艘船、第三艘船和第四艘船，共有 2 + 2 + 1 = 5 个乘客，分别是来自国家 2，3，3，4，5 ，共来自 4 个不同的国家。

【数据规模与约定】
对于 10% 的测试点， n = 1，∑k_i≤10，1≤x_i,j≤10，1≤t_i≤10；
对于 20% 的测试点， 1≤n≤10，∑k_i≤100，1≤x_i,j≤100，1≤t_i≤32767 ；
对于 40% 的测试点，  1≤n≤100，∑k_i≤100，1≤x_i,j≤100，1≤t_i≤86400 ；
对于 70% 的测试点，  1≤n≤1000，∑k_i≤3000，1≤x_i,j≤1000，1≤t_i≤10⁹ ；
对于 100% 的测试点，  1≤n≤10⁵，∑k_i≤3×10⁵，1≤x_i,j≤10⁵，1≤t_i≤10⁹ 。

//==================================================================================

最早我看到这道题就用普通数组来存组这堆数据，一个一维数组存t，一个一维数组来存k，但是，编了一半就发现了爆空间的问题，于是删掉它，用向量vector来编它，再定义一个ans数组存答案，每一次计算出从这艘船开始向前一直找到超过86400秒的一艘船，删掉它们的内存，再从剩下的第一条船开始计算，统计(统计过程用桶排序式来)，一直到目前的一条船。

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;

int const Time=86400;
int n;
vectorship[100005];
mapbook;
int head=1;

void input(int i)//传入船的编号
{
int t,k;
scanf("%d%d",&t,&k);
ship[i].push_back(t);//ship[i][0]是时间
int x;
for(int j=1;j<=k;j++)
{
scanf("%d",&x);//国籍
ship[i].push_back(x);
}
return ;
}

void Clear(int i)
{
int j=head;
while((ship[i][0]-ship[j][0]+1)>Time)
{
ship[j].clear();
head++;
j++;
}
return ;
}

int comp(int i)
{
int ans=0;
book.clear();//book清空
Clear(i);//清除24小时以外的数据

int Size;
for(int j=head;j<=i;j++)//计算从头到当前
{
Size=ship[j].size()-1;
for(int h=1;h<=Size;h++)//计算目前一艘船
{
if(!book.count(ship[j][h]))
{
ans++;
book[ship[j][h]]=1;
}
}
}
return ans;
}

void work()
{
scanf("%d",&n);
int ans[n+1];
for(int i=1;i<=n;i++)
{
input(i);
ans[i]=comp(i);
}

for(int i=1;i<=n;i++)
printf("%d\n",ans[i]);
}

int main()
{
work();
return 0;
}

之前
这个代码用的向量，提交前我估计空间应没有问题，提交了果然没爆空间。但是却爆了时间！我在我的程序中寻找重复部分，找到了每次一艘船加入后，所有船都会再次计算，于是，我想，可以编一个Clear和Inesrt函数，每次去掉24小时前的人，加上才上岸的人，但是，在避免人数重复的问题上面(如应去掉的船上有1号国家，但剩下的国家(包括新国家)。也有1号国家，则ans不能减1)，我决定用子段的方式来计算，用一个数组来存储，数组中的数据表示所有到岸的人共有多少个人，再来控制ans的加减(同样，结合超时的程序的存储方式)，就可以大大的提高程序效率，编出成功的代码。

代码非常简单，如下：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
int const Time=86400;
int n;
mapship;
int head=1;
int ans=0;
vectork;
vectorboat[100005];//存储数据

void Insert(int i,int k)//包含输入和处理数据
{
int x;

for(int j=1;j<=k;j++)
{
scanf("%d",&x);
boat[i].push_back(x);
if(!ship[x])ans++;//本来就没人，却新来了一个，所以ans++
ship[x]++;
}
return ;
}

void Clear(int i)//处理离开的数据
{
for(int j=head;j{
if(boat[i][0]-boat[j][0]break;
for(int h=1;h<=k[j];h++)
{
ship[boat[j][h]]--;
if(!ship[boat[j][h]])ans--;//没人了
}
head++;
boat[j].clear();
}
return ;
}

void comp()
{
k.push_back(0);//处理掉k[0]
scanf("%d",&n);
int ti,kn;
int i;
for(int j=1;j<=n;j++)
{
scanf("%d%d",&ti,&kn);
boat[j].push_back(ti); k.push_back(kn);//存储数据
Insert(j,kn);
Clear(j);
printf("%d\n",ans);
}
return ;
}

int main()
{
comp();
return 0;
}

程序总体总结:
爆空间的处理方式:
1、使用向量、映射(常用以当桶)
2、边输入边处理，处理了就清内存(用向量的前提)
报时间的处理方式:
1、寻找
①找循环很大的部分
②找重复处理的部分(代入一个数字，寻找重合的部分)
2、处理
①对于循环大:首先看中途可否“break”，再考虑算法优化。
②对于重复处理:首先看能否做记号解决，再考虑算法优化。