0
点赞
收藏
分享

微信扫一扫

最强DE 战斗力 【大数】

无愠色 2023-03-03 阅读 63
#include运算符i++Python后端开发


最强DE 战斗力


Time Limit: 1 Sec   Memory Limit: 128 MB

Submit: 86  

Solved: 13

[

​​Submit​​][

​​Status​​][

​​Web Board​​]


Description


春秋战国时期，赵国地大物博，资源非常丰富，人民安居乐业。但许多国家对它虎视眈眈，准备联合起来对赵国发起一场战争。

显然，面对多个国家的部队去作战，赵国的兵力明显处于劣势。战斗力是决定战争成败的关键因素，一般来说，一支部队的战斗力与部队的兵力成正比。但当把一支部队分成若干个作战队伍时，这个部队的战斗力就会大大的增强。

一支部队的战斗力是可以通过以下两个规则计算出来的：

1.若一支作战队伍的兵力为N，则这支作战队伍的战斗力为N；

2.若将一支部队分为若干个作战队伍，则这支部队的总战斗力为这些作战队伍战斗力的乘积。

比如：一支部队的兵力为5时的战斗力分析如下：

 

情况

作战安排

总的战斗力

1

1，1，1，1，1（共分为5个作战队伍）

1*1*1*1*1=1

2

1，1，1，2   （共分为4个作战队伍）

1*1*1*2=2

3

1，2，2     （共分为3个作战队伍）

1*2*2=4

4

1，1，3     （共分为3个作战队伍）

1*1*3=3

5

2，3        （共分为2个作战队伍）

2*3=6

6

1，4        （共分为2个作战队伍）

1*4=4

7

5           （共分为1个作战队伍）

5=5

显然，将部队分为2个作战队伍（一个为2，另一个为3），总的战斗力达到最大！


Input


第一行： N        表示有N组测试数据。  (2<=N<=5)

接下来有N行，每行有一个整数Ti 代表赵国部队的兵力。 （1 <= Ti <= 1000）i=1，…N


Output


对于每一行测试数据，输出占一行，仅一个整数S， 表示作战安排的最大战斗力。


Sample Input

2

5

4

Sample Output

6

4

HINT



#include <stdio.h>
#include <iostream>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <ctype.h>
#include <time.h>
#include <queue>
#include <iterator>

using namespace std;

#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4

class BigNum
{
private:
  int a[1000];  //可以控制大数的位数
  int len;
public:
  BigNum(){ len = 1; memset(a, 0, sizeof(a)); }  //构造函数
  BigNum(const int);     //将一个int类型的变量转化成大数
  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 int &)const;     //大数的n次方运算
  int operator%(const int &)const;        //大数对一个int类型的变量进行取模运算
  bool operator>(const BigNum &T)const;   //大数和另一个大数的大小比较
  bool operator>(const int &t)const;      //大数和一个int类型的变量的大小比较

  void print();        //输出大数
};
BigNum::BigNum(const int b)   //将一个int类型的变量转化为大数
{
  int c, d = b;
  len = 0;
  memset(a, 0, sizeof(a));
  while (d>MAXN)
  {
    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[t1.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;
}
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;
}
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");
}

int a[3010];
BigNum p[3010];


int main(void)
{
  int i, n;

  cin >> n;
  while (n--)
  {
    cin >> i;
    if (i == 1)
      cout << "1" << endl;
    else
    {
      BigNum bign(1);
      while (i)
      {

        if (i == 1)
        {
          bign = (bign / 3) * 4;
          i -= 1;
        }
        else if (i == 2)
        {
          bign = bign * 2;
          i -= 2;
        }
        else
        {
          bign = bign * 3;
          i -= 3;
        }

      }
      bign.print();
    }
  }
  return 0;
}




举报

相关推荐

nyoj541 最强DE 战斗力 (大数问题)

nyoj541nyoj-541java#include字符串模拟编程语言

矩阵中战斗力最弱的k行

算法

矩阵中战斗力最弱的 K 行

今日算法

LeetCode 1337. 矩阵中战斗力最弱的 K 行

矩阵leetcode算法复杂度i++虚拟化云计算

nginx优化加强战斗力及遇到的坑解决

nginx 优化nginx客户端xmlHarmonyOS后端开发

吃鸡玩家必备！提升战斗力，分享干货，保护账号安全！

云原生计算存储分离

【LeetCode】1337. 矩阵中战斗力最弱的 K 行（C++）

c++leetcode数组Spark大数据

Python描述 LeetCode 1337. 矩阵中战斗力最弱的 K 行

leetcode算法职场和发展python公众号编程语言

吃鸡玩家必备神器！一站式提升战斗力、分享干货！

游戏人工智能游戏策划大数据生活

【每日挠头算法题】LeetCode 1337. 矩阵中战斗力最弱的 K 行 —— 二分 + 排序 / 堆

算法二分查找堆leetcode数据结构
0 条评论