Language: C++

#include<bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
#define sz(v) (int)(v.size())

#define rep(i,a,n) for(int i=a;i<n;++i)

#define per(i,a,n) for(int i=n-1;i>=a;--i)

#define mem(a,t) memset(a,t,sizeof(a))

#define pb push_back

#define mp make_pair

#define fi first

#define se second

#define N 25



#define MAXN 9999

#define MAXSIZE 1010

#define DLEN 4
class BigNum

{

private:

    int a[500];  //可以控制大数的位数

    int len;

public:

    BigNum(){len=1;memset(a,0,sizeof(a));}  //构造函数

    BigNum(const int);     //将一个int类型的变量转化成大数

    BigNum(const __int64);  //将一个__int64类型的变量转化成大数

    BigNum(const char*);   //将一个字符串类型的变量转化为大数

    BigNum(const BigNum &); //拷贝构造函数

    BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算

    friend istream& operator>>(istream&,BigNum&); //重载输入运算符

    friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符



    BigNum operator+(const BigNum &)const;  //重载加法运算符，两个大数之间的相加运算

    BigNum operator-(const BigNum &)const;  //重载减法运算符，两个大数之间的相减运算

    BigNum operator*(const BigNum &)const;  //重载乘法运算符，两个大数之间的相乘运算

    BigNum operator/(const int &)const;     //重载除法运算符，大数对一个整数进行相除运算

    BigNum operator/(const __int64 &)const;     //重载除法运算符，大数对一个64位整数进行相除运算

    BigNum operator^(const int &)const;     //大数的n次方运算

    int operator%(const int &)const;        //大数对一个int类型的变量进行取模运算



    __int64 operator%(const __int64 &)const;    //大数对一个__int64类型的变量进行取模运算

    bool operator>(const BigNum &T)const;   //大数和另一个大数的大小比较

    bool operator>(const int &t)const;      //大数和一个int类型的变量的大小比较



    bool operator>(const __int64 &t)const;   //大数和一个__int64类型的变量的大小比较

    void print();        //输出大数

};

BigNum::BigNum(const int b)   //将一个int类型的变量转化为大数

{

    int c,d=b;

    len=0;

    memset(a,0,sizeof(a));

    while(d>MAXN)  //每位存四位数字，MAXN=9999；

    {

        c=d-(d/(MAXN+1))*(MAXN+1);

        d=d/(MAXN+1);

        a[len++]=c;

    }

    a[len++]=d;

}

BigNum::BigNum(const __int64 b)   //将一个int类型的变量转化为大数

{

    __int64 c,d=b;

    len=0;

    memset(a,0,sizeof(a));

    while(d>MAXN)  //每位存四位数字，MAXN=9999；

    {

        c=d-(d/(MAXN+1))*(MAXN+1);

        d=d/(MAXN+1);

        a[len++]=c;

    }

    a[len++]=d;

}

BigNum::BigNum(const char *s)  //将一个字符串类型的变量转化为大数

{

    int t,k,index,L,i;

    memset(a,0,sizeof(a));

    L=strlen(s);

    len=L/DLEN;

    if(L%DLEN)len++;

    index=0;

    for(i=L-1;i>=0;i-=DLEN)

    {

        t=0;

        k=i-DLEN+1;

        if(k<0)k=0;

        for(int j=k;j<=i;j++)

            t=t*10+s[j]-'0';

        a[index++]=t;

    }

}

BigNum::BigNum(const BigNum &T):len(T.len)  //拷贝构造函数

{

    int i;

    memset(a,0,sizeof(a));

    for(i=0;i<len;i++)

        a[i]=T.a[i];

}

BigNum & BigNum::operator=(const BigNum &n)  //重载赋值运算符，大数之间赋值运算

{

    int i;

    len=n.len;

    memset(a,0,sizeof(a));

    for(i=0;i<len;i++)

        a[i]=n.a[i];

    return *this;

}

istream& operator>>(istream &in,BigNum &b)

{

    char ch[MAXSIZE*4];

    int i=-1;

    in>>ch;

    int L=strlen(ch);

    int count=0,sum=0;

    for(i=L-1;i>=0;)

    {

        sum=0;

        int t=1;

        for(int j=0;j<4&&i>=0;j++,i--,t*=10)

        {

            sum+=(ch[i]-'0')*t;

        }

        b.a[count]=sum;

        count++;

    }

    b.len=count++;

    return in;

}

ostream& operator<<(ostream& out,BigNum& b)  //重载输出运算符

{

    int i;

    cout<<b.a[b.len-1];

    for(i=b.len-2;i>=0;i--)

    {

        printf("%04d",b.a[i]);

    }

    return out;

}

BigNum BigNum::operator+(const BigNum &T)const   //两个大数之间的相加运算

{

    BigNum t(*this);

    int i,big;

    big=T.len>len?T.len:len;

    for(i=0;i<big;i++)

    {

        t.a[i]+=T.a[i];

        if(t.a[i]>MAXN)

        {

            t.a[i+1]++;

            t.a[i]-=MAXN+1;

        }

    }

    if(t.a[big]!=0)

       t.len=big+1;

    else t.len=big;

    return t;

}

BigNum BigNum::operator-(const BigNum &T)const  //两个大数之间的相减运算

{

    int i,j,big;

    bool flag;

    BigNum t1,t2;

    if(*this>T)

    {

        t1=*this;

        t2=T;

        flag=0;

    }

    else

    {

        t1=T;

        t2=*this;

        flag=1;

    }

    big=t1.len;

    for(i=0;i<big;i++)

    {

        if(t1.a[i]<t2.a[i])

        {

            j=i+1;

            while(t1.a[j]==0)

                j++;

            t1.a[j--]--;

            while(j>i)

                t1.a[j--]+=MAXN;

            t1.a[i]+=MAXN+1-t2.a[i];

        }

        else t1.a[i]-=t2.a[i];

    }

    t1.len=big;

    while(t1.a[len-1]==0 && t1.len>1)

    {

        t1.len--;

        big--;

    }

    if(flag)

        t1.a[big-1]=0-t1.a[big-1];

    return t1;

}

BigNum BigNum::operator*(const BigNum &T)const  //两个大数之间的相乘

{

    BigNum ret;

    int i,j,up;

    int temp,temp1;

    for(i=0;i<len;i++)

    {

        up=0;

        for(j=0;j<T.len;j++)

        {

            temp=a[i]*T.a[j]+ret.a[i+j]+up;

            if(temp>MAXN)

            {

                temp1=temp-temp/(MAXN+1)*(MAXN+1);

                up=temp/(MAXN+1);

                ret.a[i+j]=temp1;

            }

            else

            {

                up=0;

                ret.a[i+j]=temp;

            }

        }

        if(up!=0)

           ret.a[i+j]=up;

    }

    ret.len=i+j;

    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;

    return ret;

}

BigNum BigNum::operator/(const int &b)const  //大数对一个整数进行相除运算

{

    BigNum ret;

    int i,down=0;

    for(i=len-1;i>=0;i--)

    {

        ret.a[i]=(a[i]+down*(MAXN+1))/b;

        down=a[i]+down*(MAXN+1)-ret.a[i]*b;

    }

    ret.len=len;

    while(ret.a[ret.len-1]==0 && ret.len>1)

        ret.len--;

    return ret;

}

BigNum BigNum::operator/(const __int64 &b)const  //大数对一个整数进行相除运算

{

    BigNum ret;

    __int64 i,down=0;

    for(i=len-1;i>=0;i--)

    {

        ret.a[i]=(a[i]+down*(MAXN+1))/b;

        down=a[i]+down*(MAXN+1)-ret.a[i]*b;

    }

    ret.len=len;

    while(ret.a[ret.len-1]==0 && ret.len>1)

        ret.len--;

    return ret;

}

int BigNum::operator%(const int &b)const   //大数对一个 int类型的变量进行取模

{

    int i,d=0;

    for(i=len-1;i>=0;i--)

        d=((d*(MAXN+1))%b+a[i])%b;

    return d;

}

__int64 BigNum::operator%(const __int64 &b)const   //大数对一个 64位整数类型的变量进行取模

{

    __int64 i,d=0;

    for(i=len-1;i>=0;i--)

        d=((d*(MAXN+1))%b+a[i])%b;

    return d;

}

BigNum BigNum::operator^(const int &n)const  //大数的n次方运算

{

    BigNum t,ret(1);

    int i;

    if(n<0)exit(-1);

    if(n==0)return 1;

    if(n==1)return *this;

    int m=n;

    while(m>1)

    {

        t=*this;

        for(i=1;(i<<1)<=m;i<<=1)

           t=t*t;

        m-=i;

        ret=ret*t;

        if(m==1)ret=ret*(*this);

    }

    return ret;

}

bool BigNum::operator>(const BigNum &T)const    //大数和另一个大数的大小比较

{

    int ln;

    if(len>T.len)return true;

    else if(len==T.len)

    {

        ln=len-1;

        while(a[ln]==T.a[ln]&&ln>=0)

          ln--;

        if(ln>=0 && a[ln]>T.a[ln])

           return true;

        else

           return false;

    }

    else

       return false;

}

bool BigNum::operator>(const int &t)const  //大数和一个int类型的变量的大小比较

{

    BigNum b(t);

    return *this>b;

}

void BigNum::print()   //输出大数

{

    int i;

    printf("%d",a[len-1]);

    for(i=len-2;i>=0;i--)

      printf("%04d",a[i]);

    printf("\n");

}
bool cmp(int a,int b){if(a<0)a*=(-1);if(b<0)b*=(-1); return a>b;}
int main(){
int n,k;cin >> n >> k;
vector<int>a(n);
for(int i = 0;i<n;i++) cin >> a[i];
BigNum ans = 1;
if(n==k){
    for(int i = 0;i<n;i++){
        ans = ans*a[i];}
        ans = ans%mod;
    cout << ans;
    return 0;
}
else{
    vector<bool>b(n,0);
    sort(a.begin(),a.end(),cmp);
    //for(int i = 0;i<n;i++) cout << a[i] <<' ';
    for(int i = 0;i<n;i++){
        if(a[i]>=0) b[i] = 1;
        else a[i] = a[i]*(-1);
    }
    int num1 = 0;int num2 = 0;int c = 0;int e = 0;
    for(int i = 0;i<k;i++){
        ans = ans*a[i];
        if(b[i]==1) {num1++;e = a[i];}//smallest positive
        else {num2++;c = a[i];}//smallest negative
    }
    if(e==0){
        ans = 1;
        sort(a.begin(),a.end());
        for(int i = 0;i<k;i++){
            ans = ans*a[i];
        }
        if(k%2) ans = ans*(-1);
        ans = (ans+mod)%mod;
        cout << ans;
        return 0;
    }
    if(num2%2){
            int d = 0;int f = 1;
        for(int i = k;i<n;i++){
            if(b[i]==1) {d = a[i];break;}//largest positive
        }
        for(int i = k;i<n;i++){
            if(b[i]==0){f = a[i];break;}//largest negative
        }
    if(ans/e*f>ans/c*d) ans = ans/e*f;
    else ans = ans/c*d;
    ans =  ans%mod;
    cout << ans;
    }
    else cout << ans;
}
return 0;
}

Compiler output:
a.cc:45:18: error: '__int64' does not name a type; did you mean '__int64_t'?
   45 |     BigNum(const __int64);  //将一个__int64类型的变量转化成大数
      |                  ^~~~~~~
      |                  __int64_t
a.cc:45:5: error: 'BigNum::BigNum(int)' cannot be overloaded with 'BigNum::BigNum(int)'
   45 |     BigNum(const __int64);  //将一个__int64类型的变量转化成大数
      |     ^~~~~~
a.cc:43:5: note: previous declaration 'BigNum::BigNum(int)'
   43 |     BigNum(const int);     //将一个int类型的变量转化成大数
      |     ^~~~~~
a.cc:67:28: error: '__int64' does not name a type; did you mean '__int64_t'?
   67 |     BigNum operator/(const __int64 &)const;     //重载除法运算符，大数对一个64位整数进行相除运算
      |                            ^~~~~~~
      |                            __int64_t
a.cc:67:12: error: 'BigNum BigNum::operator/(const int&) const' cannot be overloaded with 'BigNum BigNum::operator/(const int&) const'
   67 |     BigNum operator/(const __int64 &)const;     //重载除法运算符，大数对一个64位整数进行相除运算
      |            ^~~~~~~~
a.cc:65:12: note: previous declaration 'BigNum BigNum::operator/(const int&) const'
   65 |     BigNum operator/(const int &)const;     //重载除法运算符，大数对一个整数进行相除运算
      |            ^~~~~~~~
a.cc:75:5: error: '__int64' does not name a type; did you mean '__int64_t'?
   75 |     __int64 operator%(const __int64 &)const;    //大数对一个__int64类型的变量进行取模运算
      |     ^~~~~~~
      |     __int64_t
a.cc:83:26: error: '__int64' does not name a type; did you mean '__int64_t'?
   83 |     bool operator>(const __int64 &t)const;   //大数和一个__int64类型的变量的大小比较
      |                          ^~~~~~~
      |                          __int64_t
a.cc:83:10: error: 'bool BigNum::operator>(const int&) const' cannot be overloaded with 'bool BigNum::operator>(const int&) const'
   83 |     bool operator>(const __int64 &t)const;   //大数和一个__int64类型的变量的大小比较
      |          ^~~~~~~~
a.cc:79:10: note: previous declaration 'bool BigNum::operator>(const int&) const'
   79 |     bool operator>(const int &t)const;      //大数和一个int类型的变量的大小比较
      |          ^~~~~~~~
a.cc:115:22: error: '__int64' does not name a type; did you mean '__int64_t'?
  115 | BigNum::BigNum(const __int64 b)   //将一个int类型的变量转化为大数
      |                      ^~~~~~~
      |                      __int64_t
a.cc:115:1: error: redefinition of 'BigNum::BigNum(int)'
  115 | BigNum::BigNum(const __int64 b)   //将一个int类型的变量转化为大数
      | ^~~~~~
a.cc:89:1: note: 'BigNum::BigNum(int)' previously defined here
   89 | BigNum::BigNum(const int b)   //将一个int类型的变量转化为大数
      | ^~~~~~
a.cc:481:32: error: '__int64' does not name a type; did you mean '__int64_t'?
  481 | BigNum BigNum::operator/(const __int64 &b)const  //大数对一个整数进行相除运算
      |                                ^~~~~~~
      |                                __int64_t
a.cc:481:8: error: redefinition of 'BigNum BigNum::operator/(const int&) const'
  481 | BigNum BigNum::operator/(const __int64 &b)const  //大数对一个整数进行相除运算
      |        ^~~~~~
a.cc:453:8: note: 'BigNum BigNum::operator/(const int&) const' previously defined here
  453 | BigNum BigNum::operator/(const int &b)const  //大数对一个整数进行相除运算
      |        ^~~~~~
a.cc:523:1: error: '__int64' does not name a type; did you mean '__int64_t'?
  523 | __int64 BigNum::operator%(const __int64 &b)const   //大数对一个 64位整数类型的变量进行取模
      | ^~~~~~~
      | __int64_t