本博客中的所有算法题来源于实验室czc对蓝桥杯三年的赛题整理。
此处只记录个人的做题思路，相关打卡，内部人员自行完成
注意:补充一条消息，在提交代码得时候发现上次刷蓝桥杯的题目有几题无法通过，在博客中我会把我错误的代码给出
请诸位看客打脸
四平方和
四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。对于这个问题，我提出两种解决方式：
第一种：直接暴力穷举，sqrt()限制下；幸运的是复杂度没超
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int main()
{
long long a,b,c,num;
int flag=0;
cin>>num;//输入一个数
double d,tm;
tm=sqrt(num);
for(a=0;a<=tm;a++)
{
for(b=a;b<=tm;b++)
{
for(c=b;c<=tm;c++)//满足了从小到大的顺序
{
d=sqrt(num-a*a-b*b-c*c);
if(d==(int)d)//此时说明d也是一个整数那么此时的a,b,c,d符合题目要求
{
flag=1;
printf("%ld %ld %ld %ld\n",a,b,c,int(d));
break;
}
}
if(flag)
break;
}
if(flag)
break;
}
return 0;
} 在正常的情况下，我们都会担心算法的空间与复杂度的问题，这题只能作为走运。下面的方法在思想上并没有变化。只是尽可能的简化了算法的复杂度情况
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int tot[5000010]={0};//1成立0不成立
long long num;
void init()
{
for(int i = 0 ; i*i <= num ; i ++)
for(int j = 0 ; j*j <=num ; j ++)
if(i*i+j*j <= num) tot[i*i+j*j] = 1;
}
int main()
{
int flag=0;
cin>>num;
init();
for(int i = 0 ; i * i <= num ; i ++)
{
for(int j = 0 ; j * j <= num ; j ++){
if(tot[num - i*i - j*j] == 0)
continue; //如果剩下的差用两个完全平方数不能组合出来就不继续
for(int k = 0 ; k * k <= num ; k ++)
{
int temp = num - i*i - j*j - k*k;
double l = sqrt((double) temp);
if(l == (int)l )
{
printf("%d %d %d %d\n",i,j,k,(int)l);
flag = true;
break;
}
}
if(flag)break;
}
if(flag)break;
}
return 0;
}交换瓶子
交换瓶子
有N个瓶子，编号 1 ~ N，放在架子上。
比如有5个瓶子：
2 1 3 5 4
要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5
对于这么简单的情况，显然，至少需要交换2次就可以复位。
如果瓶子更多呢？你可以通过编程来解决。
输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。
例如，输入：
5
3 1 2 5 4
程序应该输出：
3
再例如，输入：
5
5 4 3 2 1
程序应该输出：
2
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。以 3 1 2 5 4为列
2 1 3 5 4 ans=1
1 2 3 5 4 ans=2
1 2 3 4 5 ans=3
#include <iostream>
#include <stdio.h>
using namespace std;
int tot[10010];//按照题目要求10000
inline void swap(int a,int b)//inline内嵌函数
{
int t=tot[a];
tot[a]=tot[b];
tot[b]=t;
}
int main()
{
int num;cin>>num;
int ans=0;
for(int i=1;i<=num;i++)
cin>>tot[i];
for(int i=1;i<=num;i++)
{
while(i!=tot[i])
{
swap(i,tot[i]);
ans++;
}
}
cout<<ans<<endl;
return 0;
}最大比列
最大比例
X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：
16,24,36,54
其等比值为：3/2
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
输入格式：
第一行为数字N，表示接下的一行包含N个正整数(n<100)
第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额
要求输出：
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数
测试数据保证了输入格式正确，并且最大比例是存在的。
例如，输入：
3
1250 200 32
程序应该输出：
25/4
再例如，输入：
4
3125 32 32 200
程序应该输出：
5/2
再例如，输入：
3
549755813888 524288 2
程序应该输出：
4/1
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
#include <iostream>
#include <stdio.h>
#include <set>
using namespace std;
//最大比例问题
const int N=110;//。
long long arr[N];
long long gcd(long long a,long long b)
{
if(a<b)
swap(a,b);
return b==0?a:gcd(b,a%b);//辗转相除求最大公约数
}
long long fi(long long a,long long b)
{
if(a<b)
swap(a,b);
if(a==b)
return a;
else
return fi(b,a/b);//目的是求得嘴简得分数
}
int main()
{
int n;cin>>n;
set<long long> st;
for(int i=1;i<=n;i++)
{
long long a;cin>>a;
st.insert(a);
}
int cnt=0;
for(set<long long>::iterator it=st.begin();it!=st.end();it++)
{
arr[cnt++]=*it;
}
if(cnt==1)//只输入一个数得情况
{
cout<<"1/1"<<endl;
return 0;
}
long long e=gcd(arr[0],arr[1]);
long long a=arr[0]/e,b=arr[1]/e,c,d;//初始化 a=arr[0],b=arr[1];
for(int i=1;i<cnt-1;i++)
{
e=gcd(arr[i],arr[i+1]);
c=arr[i]/e;
d=arr[i+1]/e;
a=fi(a,c);
b=fi(b,d);
}
cout<<b<<"/"<<a<<endl;
return 0;
} 日期问题：
标题：日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
输入
----
一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)
输入
----
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。
样例输入
----
02/03/04
样例输出
----
2002-03-04
2004-02-03
2004-03-02
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。这个问题我做过好多次，在博客中也写过两次。解析大致如下
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn =5;
int md[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};//12个月的日期
int ans=0;
struct Date//年月日
{
int year;
int month;
int day;
} date[maxn];
int is_year(int y)//判断是不是闰年
{
if((y%4==0 && y%100!=0) || (y%400==0))//是为1 否为0
return 1;
else
return 0;
}
int addinfo(int y,int m,int d,int n)//检查这个信息是否被添加过，如果没有返回1然后进行信息添加
{
int i;
for(i=0;i<n;i++)
{
if(date[i].year==y && date[i].month==m && date[i].day==d)
return 0;
}
return 1;
}
bool cmp(struct Date d1,struct Date d2)//排序规则的设定
{
if(d1.year==d2.year)
{
if(d1.month==d2.month)
return (d1.day<d2.day);//按照day从小到大排序
else
return (d1.month<d2.month);//按照月从小到大排序
}
else
return d1.year<d2.year;//按照年从小到大排序
}
void insertda(int y,int m,int d)
{
int ty,tm,td;
int temp;
ty=y,tm=m,td=d;
if(ty>=0 && ty<=59)
ty+=2000;
else
ty+=1900;
if(tm>=1 && tm<=12)
{
temp=md[tm];
if(tm==2 && is_year(ty))
temp++;
if(td>=1 && td<=temp && addinfo(ty,tm,td,ans))
{
date[ans].year=ty;
date[ans].month=tm;
date[ans].day=td;
ans++;
}
}
}
int main()
{
int i;
int a,b,c;
scanf("%02d/%02d/%02d",&a,&b,&c);
insertda(a,b,c);
insertda(c,a,b);
insertda(c,b,a);
sort(date,date+ans,cmp);
for(i=0;i<ans;i++)
printf("%04d-%02d-%02d\n",date[i].year,date[i].month,date[i].day);
return 0;
} 包子凑数
标题：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
----
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
输出
----
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。
例如，
输入：
2
4
5
程序应该输出：
6
再例如，
输入：
2
4
6
程序应该输出：
INF
样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
做法：这是扩展欧几里德变形的，有个定理。如果满足所有数的最大公约数不为1则有无穷个，否则都是有限个。然后利用完全背包就可以统计了。
拓展欧几里德：
1. 求整数 x和y 使得 ax + by = 1.
2. 可以发现, 如果gcd(a, b) ≠ 1，则显然无解.
3. 反之, 如果gcd(a, b) = 1, 则可以通过拓展原来的 辗转相除法 来求解.
4. 事实上,一定存在整数对(x, y)使得ax+by = gcd(a,b) = 1
如果所有 蒸笼里的包子数的最大公约数，不为1，则说明有无数种数目凑不出来。如果最大公约数为1，则说明有限个数目凑不出来。
//包子凑数
#include<bits/stdc++.h>
using namespace std;
int arr[110],n;
#define N 10010//100*100
bool bk[N];
int gcd(int a,int b){//求解最大公因数
if(b == 0) return a;
return gcd(b,a%b);
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>arr[i];
}
int g=arr[0];
for(int i=1;i<n;i++)
{
g=gcd(g,arr[i]);
}
if(g!=1)
printf("INF\n");
else
{
bk[0]=true;
for(int i=0;i<n;i++)//n个笼子
{
for(int j=0;j+arr[i]<N;j++)
if(bk[j])
bk[j+arr[i]]=true;//.....
}
int count=0;
for(int i=N-1;i>=0;i--)
{
if(bk[i]==false)
count++;
}
cout<<count<<endl;
}
return 0;
} 分巧克力
标题： 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入：
2 10
6 5
5 6
样例输出：
2
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
1. 经典的利用二分求解最大最小值问题，主要就是判断条件C的编写。模板题。
2. 还有就是二分搜索法的结束判定，推荐用直接循环100次，100次循环可以达到10^-30的精度范围，足够了。不推荐用while (lh < rh) 感觉容易死循环
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;
const int maxn = 100000 + 100;
int N, K;
struct Food {
int Hi,
Wi;
Food(int h = 0, int w = 0) : Hi(h), Wi(w) {}
} fds[maxn];
//可以切出来 K 个 边长为x 的正方形
bool C(int x)
{
int ans = 0;
for (int i = 0; i < N; i++)
{
ans += (fds[i].Hi / x) * (fds[i].Wi / x);
if (ans >= K) return true;
}
return ans >= K;
}
void solve()
{
cin >> N >> K;
int INF = 0;
for (int i = 0; i < N; i++)
{
scanf("%d%d", &fds[i].Hi, &fds[i].Wi);
INF = max(INF, max(fds[i].Hi, fds[i].Wi));
}
int lh = 0, rh = INF + 1;
int mid = 0;
for (int i = 0; i < 100; i++)
{
mid = (lh + rh) / 2;
if (C(mid)) {
lh = mid;
}
else {
rh = mid;
}
}
cout << lh << endl;
}
int main()
{
solve();
return 0;
}k倍区间
标题： k倍区间
给定一个长度为N的数列，A1, A2, ... AN，如果其中一段连续的子序列Ai, Ai+1, ... Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入
-----
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出
-----
输出一个整数，代表K倍区间的数目。
例如，
输入：
5 2
1
2
3
4
5
程序应该输出：
6
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll bk[100010]={0};
ll arr[100010];
ll k,n;
int main()
{
scanf("%lld%lld",&n,&k);
for(int i = 0 ; i < n ; i ++)
scanf("%lld",&arr[i]);
arr[0] %= k;
ll sum = 0;
for(int i = 1 ; i < n ; i ++)
arr[i] = (arr[i]+arr[i-1])%k;
for(int i = 0 ; i < n ; i ++)
sum += (bk[arr[i]]++);
printf("%lld\n",sum+bk[0]);
return 0;
}螺旋折线
题目地址
http://oj.nhjc.ac.cn/contest/4/problem/I
//螺旋折线
//这道题的主要难度是规律很不好找
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ll x , y;
ll res;
cin>>x>>y;
if(y > 0)
{
if(abs(x)<=y)
res=4*y*y-y+x;
else
{
if(x>0)
res=4*x*x+x-y;
else
res=4*x*x+3*x+y;
}
}
else
{
if(y-1 <= x &&x <= -y)
res=7*-y+(y*y+y)/2*8-x;
else
{
if(x > 0)
res=7*x+(x*x-x)/2*8-2*x-y;
else
res=-7*x-7+(x*x+3*x+2)/2*8-2*x+y-1;
}
}
cout<<res;
return 0;
}
日志统计
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <set>
#include <vector>
using namespace std;
const int maxn = 100000 + 5;
struct Node
{
int ts, id;
};
bool cmp(Node p, Node q)
{
return p.ts < q.ts;
}
Node a[maxn];
vector<int> t[maxn];
set<int> ans;
int n, k, d;
int bs(int i)//二分找值在区间[T-D,T]内最小下标
{
int m = t[i][t[i].size() - 1];
int lo = 0, hi = t[i].size() - 1, mid, res = t[i].size();
while (lo <= hi)
{
mid = (hi + lo) / 2;
if (t[i][mid] >= m - d)
{
res = min(res, mid);
hi = mid - 1;
}
else
lo = mid + 1;
}
return res;
}
int main()
{
cin >> n >>d >> k;
d--;//[T,T+D) => [T,T+D-1]
for (int i = 0; i < n; i++)
cin >> a[i].ts >> a[i].id;
sort(a, a + n, cmp);
for (int i = 0; i < n; i++)
{
t[a[i].id].push_back(a[i].ts);
int cnt = t[a[i].id].size() - bs(a[i].id);
if (cnt >= k)
ans.insert(a[i].id);
}
for (set<int>::iterator i = ans.begin(); i != ans.end(); i++)
{
cout << *i << endl;
}
return 0;
}全球变暖
http://oj.nhjc.ac.cn/contest/4/problem/K
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
using namespace std;
typedef long long ll;
const int maxn = 1e6+5;
const double esp = 1e-7;
const int ff = 0x3f3f3f3f;
map<int,int>::iterator it;
struct node
{
int x,y;
node(int x = 0,int y = 0):x(x),y(y){}
};
int n;
int cnt;
char mp[1005][1005];
int vis[1005][1005];
vector<node> d[maxn];
int ne[4][2] = {1,0,-1,0,0,1,0,-1};
void find(int x,int y)//寻找相连点
{
d[cnt].push_back(node(x,y));
vis[x][y] = 1;
for(int i = 0;i< 4;i++)
{
int tx = x+ne[i][0];
int ty = y+ne[i][1];
if(tx< 0||tx>= n||ty< 0||ty>= n||vis[tx][ty]||mp[tx][ty] == '.')
continue;
find(tx,ty);
}
return ;
}
void Preprocess()//预处理岛屿
{
for(int i = 0;i< n;i++)
for(int j = 0;j< n;j++)
if(mp[i][j] == '#'&&!vis[i][j])
{
cnt++;
find(i,j);
}
return ;
}
void dfs(int x,int y)//侵蚀
{
vis[x][y] = 1;
for(int i = 0;i< 4;i++)
{
int tx = x+ne[i][0];
int ty = y+ne[i][1];
if(tx< 0||tx>= n||ty< 0||ty>= n||vis[tx][ty])
continue;
if(mp[tx][ty] == '#')
vis[tx][ty] = 1;
else
dfs(tx,ty);
}
return ;
}
void solve()//开始侵蚀
{
mem(vis,0);
for(int i = 0;i< n;i++)
for(int j = 0;j< n;j++)
if(mp[i][j] == '.'&&!vis[i][j])
dfs(i,j);
return ;
}
int main()
{
cin>>n;
for(int i = 0;i< n;i++)
scanf(" %s",mp[i]);
Preprocess();
solve();
int ans = 0;
for(int i = 1;i<= cnt;i++)//判断组成岛屿的点还在不在
{
int j,k = d[i].size();
for(j = 0;j< k;j++)
if(vis[d[i][j].x][d[i][j].y] == 0)
break;
if(j == k)
ans++;
}
cout<<ans<<endl;
return 0;
}乘积最大
标题：乘积最大
给定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#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define mod 1000000009
using namespace std;
typedef long long ll;
const int maxn = 1e6+5;
const double esp = 1e-7;
const int ff = 0x3f3f3f3f;
map<int,int>::iterator it;
struct node
{
ll x;
int f;
}a[maxn];
int n,k;
bool cmp(node x,node y)
{
return x.x> y.x;
}
ll solve(int o)
{
ll ans = 1;
int cnt = 0;
if(o == 0)//从前往后乘
{
for(int i = 1;i<= k;i++)
{
ans = (ans*a[i].x)%mod;
if(a[i].f == 1)
cnt++;
}
}
else//从后往前乘
{
for(int i = n;i> n-k;i--)
{
ans = (ans*a[i].x)%mod;
if(a[i].f == 1)
cnt++;
}
}
if(cnt&1)
return ans*(-1);
return ans;
}
int main()
{
cin>>n>>k;
int flag = 0;
int cnt = 0;
for(int i = 1;i<= n;i++)
{
scanf("%lld",&a[i].x);
if(a[i].x< 0)
{
a[i].f = 1;
a[i].x = -a[i].x;
cnt++;
}
else if(a[i].x> 0)
a[i].f = 0;
else
{
i--;n--;//我们不记录0，0只做迫不得已的选择
flag = 1;
}
}
sort(a+1,a+n+1,cmp);
ll ans = 0;
if(n< k)//如果必须选0
ans = 0;
else if(cnt == n)//如果都为负数
{
if(k&1)
ans = solve(1);
else
ans = solve(0);
}
else if(cnt == 0)//如果都为正数
ans = solve(0);
else
{
int tmp = 0;
for(int i = 1;i<= k;i++)
if(a[i].f == 1)
tmp++;
if(tmp%2 == 0)//如果前k大的数有偶数个负数
ans = solve(0);
else
{
ans = -1;//将其设置为负数
//尝试将前k个里面一个绝对值最小负数和后面最大正数交换
int p = -1,q = -1;
for(int i = k+1;i<= n;i++)
if(a[i].f == 0)
{
q = i;
break;
}
for(int i = k;i>= 1;i--)
if(a[i].f == 1)
{
p = i;
break;
}
if(p!= -1&&q!= -1)
{
swap(a[p],a[q]);
ans = solve(0);
swap(a[p],a[q]);
}
//尝试将前k个里面一个最小正数和后面绝对值最大正数交换
p = -1,q = -1;
for(int i = k+1;i<= n;i++)
if(a[i].f == 1)
{
q = i;
break;
}
for(int i = k;i>= 1;i--)
if(a[i].f == 0)
{
p = i;
break;
}
if(p!= -1&&q!= -1)
{
swap(a[p],a[q]);
ans = max(ans,solve(0));
swap(a[p],a[q]);
}
//假如结果仍然小于0，我们只能尝试从最后往前乘了
if(ans< 0)
ans = solve(1);
}
}
if(ans< 0)
if(flag)//这时候0派上用场了
{
cout<<0<<endl;
return 0;
}
cout<<ans<<endl;
return 0;
}