18年省赛真题笔记
1.第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
1.1思路
简单题，要注意的只有2000是闰年，2月 29天
1.2源码
#include<stdio.h>
int main()
{
printf("%d",31+29+31+30+4);
return 0;
2.明码
汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。
16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。
一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。
把每个字节转为2进制表示，1表示墨迹，0表示底色。每行2个字节，
一共16行，布局是：
第1字节，第2字节
第3字节，第4字节
....
第31字节, 第32字节
这道题目是给你一段多个汉字组成的信息，每个汉字用32个字节表示，这里给出了字节作为有符号整数的值。
题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。
这段信息是（一共10个汉字）：
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4
4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64
16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128
0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0
2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0
1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0
0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0
注意：需要提交的是一个整数，不要填写任何多余内容。
2.1思路
看懂题目的意思很重要，一个汉字有32字节，每个汉字16x16像素信息，就是16x2（2就代表字节），共16行打印出来。
1.主函数可以通过双重for循环每次将两个字节输入，然后通过创建的函数打印出来
2.函数将 10 进制数转化为 2 进制数，然后通过for循环打印出来。
3.还有要注意的一点：负数2进制的求法（正数第一位是0），如果是负数，则直接令第一位为1
2.2 二进制求法
如 X
第一位：1 其他7位 128+x的2进制
正数二进制能表示范围（0 000 0001 ~ 0 111 1111）即1~127
负数二进制能能表示的范围（1 000 0001 ~ 1 111 1111）即-127~-1
2.3源码
#include<stdio.h>
#include<math.h>
int out(int t[],int a,int b){
for(int i=7;i>0;i--)
{
if(a<0){
a=a+128;
t[0]=1;
}
else{
a=a;
t[0]=0;
}
t[i]=a%2;
a/=2;
}
for(int i=0;i<=7;i++)printf("%c",t[i]? '*':' ');
for(int i=7;i>0;i--)
{
if(b<0){
b=b+128;
t[0]=1;
}
else{
a=a;
t[0]=0;
}
t[i]=b%2;
b/=2;
}
for(int i=0;i<=7;i++)printf("%c",t[i]? '*':' ');
printf("\n");
}
int main(){
int sum=1;
int a,b;
int t[8];
for(int i=0;i<10;i++){
for(int j=0;j<16;j++){
scanf("%d %d",&a,&b);
out(t,a,b);
}
}
for(int i=0;i<9;i++)
sum*=9;
printf("%d",sum);
}
3.乘积尾零
如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？
5650 4542 3554 473 946 4114 3871 9073 90 4329
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
1486 5722 3135 1170 4014 5510 5120 729 2880 9019
2049 698 4582 4346 4427 646 9742 7340 1230 7683
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
6701 6645 1671 5978 2704 9926 295 3125 3878 6785
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
689 5510 8243 6114 337 4096 8199 7313 3685 211
注意：需要提交的是一个整数，表示末尾零的个数。不要填写任何多余内容。
3.1思路
由2x5=10，可以知道，每一个0都可以2,5组成
则只要统计2,5的个数就行了。
3.2源码
#include<stdio.h>
int main(){
int sum;
int a=0,b=0;
for(int j=0;j<100;j++){
scanf("%d",&sum);
while(sum%5==0){
a++;
sum/=5;
}
while(sum%2==0){
b++;
sum/=2;
}
}
printf("%d",a>=b?b:a);
}
4.测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
4.1思路
最佳策略：就是测位于所要测的塔中间层
比如： 3层
从中间测只要测2次，而在1,3层，则要测3次。
所谓最坏运气：(测每层最多要几次)
比如：
共四层：
1.在只有一部手机的情况下，如果从高层开始测的话，摔坏了，就没法知道手机的耐摔指数，所以只能从1层开始，逐渐往上测，这样既能知道耐摔指数，又可以知道测试的次数。
当然测试次数是最主要的，由上面的图，我们就可以知道测试次数跟层数是相等的。
表示形式就是（1,1）=1，（1,2）=2。含义就是1部手机测1层的次数，1部手机测2层的次数、
2.有两部手机
从1层测起：
坏：另一部手机不用测，就能知道测试次数为1次。
好：2部手机 测另外三层。（2,3）次+1
从2层测起：
坏：另一部手机，测1层 测（1,1）次+1
好：两部手机，测两层 测（2,2）次+1
从3层测起：
坏：另一部手机，测两层，测（1,2）次+1
好：两部手机，测1层，测（2,1）次+1
从第4层测起：
坏：另一部手机，测3层，测（1,3）次+1
好：两部手机，不用继续测了，就测了1次
为什么要+1，因为本身就测了一次
然后前面说的最佳策略：就是在这个图中的2,3层，测试次数也应该在里面，然后题目也是求测试次数，思路大概就是这样。
上面的也可以简化为：
f1[n]=n
f2[n]=min(for i in n max( 1+f2[n-i] , 1+f1[i-i] )
f3[n]=min(for i in n max( 1+f3[n-i]) , 1+f2[i-1] )
4.2源码
#include<stdio.h>
#include<limits.h>
const int n=1000;
int f1[n+1],f2[n+1],f3[n+1];
/*
f1[n+1]表示的就是1部手机，测n层
如f1[1]=1,f1[2]=2
*/
int max(int a,int b){
if(a>b)
return a;
else
return b;
}
int min(int a,int b){
if(a<b)
return a;
else
return b;
}
int main(){
for(int i=1;i<=n;i++){
//求出一部手机测的次数
f1[i]=i;
}
for(int i=1;i<=n;i++){
int ans=INT_MAX;
for(int j=1;j<=i;j++){
int _max=1+max(f2[i-j],f1[j-1]);
//用到了max()函数，求两部手机测每层要花的次数
ans=min(ans,_max);
}
f2[i]=ans;
}
for(int i=1;i<=n;i++){
int ans=INT_MAX;
for(int j=1;j<=i;j++){
int _max=1+max(f3[i-j],f2[j-1]);
ans=min(ans,_max);
}
f3[i]=ans;
}
printf("%d",f3[n]);
}
5.快速排序
以下代码可以从数组a[]中找出第k小的元素。
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。
请仔细阅读分析源码，填写划线部分缺失的内容。
#include <stdio.h>
int quick_select(int a[], int l, int r, int k) {
int p = rand() % (r - l + 1) + l;
int x = a[p];
{int t = a[p]; a[p] = a[r]; a[r] = t;}
int i = l, j = r;
while(i < j) {
while(i < j && a[i] < x) i++;
if(i < j) {
a[j] = a[i];
j--;
}
while(i < j && a[j] > x) j--;
if(i < j) {
a[i] = a[j];
i++;
}
}
a[i] = x;
p = i;
if(i - l + 1 == k) return a[i];
if(i - l + 1 < k) return quick_select( _____________________________ ); //填空
else return quick_select(a, l, i - 1, k);
}
int main()
{
int a[] = {1, 4, 2, 8, 5, 7, 23, 58, 16, 27, 55, 13, 26, 24, 12};
printf("%d\n", quick_select(a, 0, 14, 5));
return 0;
}
注意：只填写划线部分缺少的代码，不要抄写已经存在的代码或符号。
5.1思路
快排的思想：就是先找一个数作为基准，然后从数组的右边 ( j - - )找一个比基准小的，从数组的左边( i + + )找一个比基准大的，然后交换这两个数。最后 i = = j,最后就把基准数放在这个位置。
这个题目的话，找出第 K 小的数，看题目：
if(i - l + 1 == k) return a[i]; ,( i - l + 1)表示的就是第几个元素，所以这句话就是 i 等于第K小的数
if(i - l + 1 < k) return quick_select( )；：这句话就是K比确定的基准 I 还要大，所以K在 i 的右边。并且位置是K-( i - l + 1 ),为什么是这样呢，还得从快排的思想说起，快排就是确定一个个基准，把数分成很多分，然后交换数的顺序。当只有一个基准时，则只有两部分，所以左边的占取了一些位置，所以需要减去左边( i - l + 1)
5.2答案
( a , i +1 , r , k - ( i - l + 1 ) )
6.递增三元组
给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：
1. 1 <= i, j, k <= N
2. Ai < Bj < Ck
【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。
对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
【输出格式】 =+
一个整数表示答案
【样例输入】
3
1 1 1
2 2 2
3 3 3
【样例输出】
27
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
6.1思路
这道题如果用暴力搜索其实挺简单的，就是先给三个数组排序，然后用三重for循环判断满足条件的个数，但是这样只能得30分。
下面有一种更好的办法：
就是把b数组当成基准，分别从a,c数组中找比b数组小的数和比b数组大的数，然后确定个数。
6.2源码
#include<stdio.h>
const int N=100001;
void sort(int a[],int n){
int t;
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(a[i]>a[j]){
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
}
}
int main(){
int a[N],b[N],c[N];
int n;
long long ans=0;
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%d",&a[i]);
for(int i=0;i<n;i++)
scanf("%d",&b[i]);
for(int i=0;i<n;i++)
scanf("%d",&c[i]);
sort(a,n); //a,b,c数组从小到大排序
sort(b,n);
sort(c,n);
int p=0,q=0; //来统计以 b数组为基准，p:比b数组小的数的个数，(n-q):比b数组大的数的个数
for(int i=0;i<n;i++){
while(p<n&&a[p]<b[i]) p++;
while(q<n&&c[q]<=b[i]) q++;
ans+=( (long long) p* (n-q) );
}
printf("%lld\n",ans);
}
7.螺旋折线
如图p1.png所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
例如dis(0, 1)=3, dis(-2, -1)=9
给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？
【输入格式】
X和Y
对于40%的数据，-1000 <= X, Y <= 1000
对于70%的数据，-100000 <= X， Y <= 100000
对于100%的数据, -1000000000 <= X, Y <= 1000000000
【输出格式】
输出dis(X, Y)
【样例输入】
0 1
【样例输出】
3
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
7.1思路
将图中（1,1）（2,2），（3,3）作为一圈结束的标志
则可以发现
2 6 10
4 8 12
可以构成等差数列 把这个分为两部分（就是两个相同的等差数列）
则可以形成 a0=1,d=1，n为圈数*2的等差数列
sum(1,2*n,1)*2-d
这个就是等差数列求和公式
7.2源码
#include<stdio.h>
#include<stdlib.h>
#define sum(a0,n,d) ( 2*a0 +((n)-1) *(d))* (n) /2 //等差数列求和
typedef long long LL;
int main(){
LL x,y;
scanf("%d %d",&x,&y);
LL d=0;//距离 如距离点（2,2）
LL n=0;//第几圈 (3,3)第3圈
if(y>0 && abs(x)<=y){ //就是第n圈中最上面平行x轴的直线
n=y;
d=y-x+2*y;
}
else if(x>0 && abs(y)<=x){//第n圈中，最右边的那条线
n=x;
d=x+y;
}
else if(y<=0 && x>=y-1 && x<=-y ){ //最底下的那条线，距离n-1圈更近
n=-y;
d=-(-y-x); //退回上一圈
}
else if(x<0&& y>=x+1 && y<=-x){
n=-x-1;
d=-(y-x-1-2*x-1);
}
printf("%d\n",sum(1,2*n,1)*2-d ); //n为什么*2？ 因为第三圈有6个格子
return 0;
}
8.日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个"赞"。
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。
给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
【输出样例】
1
3
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
8.1思路
词取法
8.2源码
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int n,d,k;
const int maxn=1e5+5;
vector<int> thing[maxn];
bool judge(int id)
{
int len=thing[id].size();
if(len<k)
return false;
sort(thing[id],thing[id]+len);
int start=0;int end=0;
int cnt=0;
while(start<=end && end<len)
{
cnt++;
if(cnt>=k)
{
if(thing[id][end]-thing[id][start]<d) //注意是小于(题中说是前闭后开区间
return true;
else //如果if语句不成立，那么你再去后移end，也是不符要求的，所以该后移start了
{
cnt--;
start++;
}
}
end++;
}
return false;
}
int main()
{
cin>>n>>d>>k;
for(int i=1;i<=n;i++)
{
int ts,id;
cin>>ts>>id;
thing[id].push_back(ts);
}
int n_things = thing.size(); //取vector的长度，即有多少个id
for(int id=1;id<=n_things;i++)
{
if(judge(id))
cout<<id<<endl;
}
return 0;
}
9.全球变暖
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
9.1思路
使用DFS对陆地进行搜索，并且对每个点进行判定，如果这个点被淹没了，那么就记录为1，反之记录为2，如果一个点的周围已经有2或者3的时候，那么这个点就记录为3，这样做的目的是为了方便寻找没有被淹没的岛屿个数。
9.2源码
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <queue>
#define N 1005
using namespace std;
char m[N][N];
int n,book[N][N],sum;
int next[4][2] = {
{1,0},
{0,1},
{-1,0},
{0,-1}
};
//判断当前搜索的点，并改变在book中的标记
void check(int x, int y)
{
int i,tx,ty,flag = 0;
//对这个点的上下左右都判断，如果这个点周围存在海洋，那么就标记为1
for(i = 0;i < 4;i++)
{
tx = x + next[i][0];
ty = y + next[i][1];
if(tx < 0 || tx >= n || ty < 0 || ty >= n)
continue;
//如果这个点周围存在没有被淹没的陆地，那么就标记为3
if(book[tx][ty] == 2 || book[tx][ty] == 3)
flag = 1;
if(m[tx][ty] == '.')
{
book[x][y] = 1;
return;
}
}
if(flag)
book[x][y] = 3;
else
book[x][y] = 2;
}
void dfs(int x, int y)
{
int i,tx,ty;
check(x, y);
for(i = 0;i < 4;i++)
{
tx = x + next[i][0];
ty = y + next[i][1];
if(tx < 0 || tx >= n || ty < 0 || ty >= n)
continue;
//搜索下一个没有搜索到的点
if(!book[tx][ty] && m[tx][ty] == '#')
dfs(tx,ty);
}
return;
}
int main()
{
int i,j;
scanf("%d",&n);
sum = 0;
for(i = 0;i < n;i++)
scanf("%s",m[i]);
for(i = 0;i < n;i++)
{
for(j = 0;j < n;j++)
{
if(m[i][j] == '#')
{
if(book[i][j] != 0)
continue;
dfs(i,j);
sum++;
}
}
}
for(i = 0;i < n;i++)
{
for(j = 0;j < n;j++)
{
if(book[i][j] == 2 && m[i][j] == '#')
sum--;
}
}
printf("%d\n",sum);
return 0;
}
10.乘积最大
给定N个整数A1, A2, ... AN。请你从中选出K个数，使其乘积最大。
请你求出最大的乘积，由于乘积可能超出整型范围，你只需输出乘积除以1000000009的余数。
注意，如果X<0， 我们定义X除以1000000009的余数是负(-X)除以1000000009的余数。
即：0-( (0-x) % 1000000009)
【输入格式】
第一行包含两个整数N和K。
以下N行每行一个整数Ai。
对于40%的数据，1 <= K <= N <= 100
对于60%的数据，1 <= K <= 1000
对于100%的数据，1 <= K <= N <= 100000 -100000 <= Ai <= 100000
【输出格式】
一个整数，表示答案。
【输入样例】
5 3
-100000
-10000
2
100000
10000
【输出样例】
999100009
再例如：
【输入样例】
5 3
-100000
-100000
-2
-100000
-100000
【输出样例】
-999999829
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
10.1思路
感觉难点在分类讨论的时候要把所有情况都考虑全，首先把这些数按照绝对值从大到小排序：
①当n==k时，只能全选了
②如果n个数全是正数，选择前k个即可
③如果n个数全是负数，如果k是偶数，选择前k个即可；如果k是奇数，选择后k个即可
④剩下的情况就是有正有负了，先看前k个数，如果负数个数为偶数，选择前k个即可；如果负数个数为奇数，则比较前面最后一个负数与后面第一个负数的乘积和前面最后一个正数与后面第一个正数的乘积哪个大，取大的即可
10.2源码
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
using namespace std;
#define N 100000
#define MOD 1000000009
struct number
{
int sign;
long long num;
}a[N];
bool cmp(const number &x,const number &y)
{
return x.num>y.num;
}
int main()
{
int n,k,cnt=0;
long long t,ans=1;
cin>>n>>k;
for(int i=0;i<n;i++)
{
cin>>t;
if(t<0)
{
a[i].sign=-1;
a[i].num=-t;
cnt++;
}
else
{
a[i].sign=1;
a[i].num=t;
}
}
if(n==k)
{
for(int i=0;i<k;i++)
ans=(ans*a[i].num)%MOD;
if(cnt&1)
ans=-ans;
}
else
{
sort(a,a+n,cmp);
if(cnt==n)//全是负数
{
if(k&1)
{
for(int i=n-1;i>n-1-k;i--)
ans=(ans*a[i].num)%MOD;
ans=-ans;
}
else
{
for(int i=0;i<k;i++)
ans=(ans*a[i].num)%MOD;
}
}
else if(cnt==0)//全是正数
{
for(int i=0;i<k;i++)
ans=(ans*a[i].num)%MOD;
}
else
{
int nega=-1,posi=-1;
cnt=0;
for(int i=0;i<k;i++)
{
if(a[i].sign==-1)
{
//nega记录前K个中最后一个负数的下标
//cnt记录前k个中负数的个数，每满2个就乘一次
cnt++;
if(nega==-1)
nega=i;
else
{
if((cnt&1)==0)//保持负数是一对的样子乘上去
{
ans=(ans*a[nega].num)%MOD;
ans=(ans*a[i].num)%MOD;
}
nega=i;
}
}
else
{
//posi记录前k个中最后一个正数的下标
//每次只乘上前一个正数，留最后一个正数作交换
if(posi==-1)
posi=i;
else
{
ans=(ans*a[posi].num)%MOD;
posi=i;
}
}
}
if((cnt&1)==0)//负数为偶数个，则直接取前k个数即可，把最后一个正数乘上即可
ans=(ans*a[posi].num)%MOD;
else
{
int nega1=-1,posi1=-1;
for(int i=k;i<n;i++)
{
if(a[i].sign==-1)//找绝对值最大的负数
{
if(nega1==-1)
nega1=i;
}
else//找最大的正数
{
if(posi1==-1)
posi1=i;
}
if(nega1!=-1&&posi1!=-1)
break;
}
if(nega1!=-1&&posi1!=-1)
{
//比较是前k个中最后一个负数和后面绝对值最大的负数乘积大
//还是前k个中最后一个正数和后面最大的正数乘积大
if(a[nega].num*a[nega1].num>a[posi].num*a[posi1].num)
{
ans=(ans*a[nega].num)%MOD;
ans=(ans*a[nega1].num)%MOD;
}
else
{
ans=(ans*a[posi].num)%MOD;
ans=(ans*a[posi1].num)%MOD;
}
}
else if(posi1!=-1)//后面只有正数了
{
ans=(ans*a[posi].num)%MOD;
ans=(ans*a[posi1].num)%MOD;
}
else//后面只有负数了
{
ans=(ans*a[nega].num)%MOD;
ans=(ans*a[nega1].num)%MOD;
}
}
}
}
cout<<ans<<endl;
return 0;
}
2744
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
