【双周赛】

 这题没什么好说的了，直接桶计数就行

#include<bits/stdc++.h>
using namespace std;
int book[11];
int jian(char c){
    if(c=='1'||c=='`'||c=='~'||c=='Q'||c=='A'||c=='Z'){
        return 1;
    }
    if(c=='2'||c=='W'||c=='S'||c=='X'){
        return 2;
    }
    if(c=='3'||c=='E'||c=='D'||c=='C'){
        return 3;
    }
    if(c=='4'||c=='R'||c=='F'||c=='V'||c=='5'||c=='T'||c=='G'||c=='B'){
        return 4;
    }
    if(c=='7'||c=='6'||c=='Y'||c=='U'||c=='H'||c=='J'||c=='N'||c=='M'){
        return 5;
    }
    if(c=='8'||c=='I'||c=='K'||c==','){
        return 6;
    }
    if(c=='9'||c=='O'||c=='L'||c=='.'){
        return 7;
    }
    else return 8;
}
int main(){
    string s;
    cin>>s;
    int l=s.length();
    for(int i=0;i<l;i++){
        book[jian(s[i])]++;
    }
    for(int i=1;i<=8;i++){
        cout<<book[i]<<endl;
    }

}

这题实际上是求两个整数的欧几里得拓展算法的结果。

#include <bits/stdc++.h>
using namespace std;
int ans;
int an(int n, int m)
{
    if (n % m == 0)
        return 0;
    else if (n < m && __gcd(m, n) == 1)
        return m - 1;
    else
    {
        return __gcd(m, n) * an(n / (__gcd(m, n)), m / (__gcd(m, n)));
    }
}
int main()
{
    int n, m;
    cin >> n >> m;
    if (n > m)
        n = n % m;
    cout << an(n, m);
}

首先，如果 n % m == 0，直接返回 0。

否则，如果 n < m 并且 n 和 m 互质，返回 m - 1。

否则，返回 (m,n) * an(n/(m,n), m/(m,n))，其中 (m,n) 表示 m 和 n 的最大公约数。求出最少的数量使得每一位能被 m 整除的主要部分，它使用了一个递归函数，求出了 n 和 m 的最大公因数，然后递归地求出了每一位能被模 m / gcd(n, m) 得到的数的最少的数量。

 

 

#include <bits/stdc++.h>
using namespace std;

// 定义一个tim结构体，表示每个活动的起始时间、结束时间以及时长
const int M = 1e6;
struct tim
{
    int st;  // 起始时间
    int ed;  // 结束时间
    int len; // 时长
} act[M];

int main()
{
    // 读入m个数据组
    int m;
    cin >> m;

    // 循环读入每组数据
    for (int j = 0; j < m; j++)
    {
        int n;
        cin >> n; // 读入n个活动
        int num = 0;
        // 循环读入每个活动的起始时间和结束时间
        for (int i = 0; i < n; i++)
        {
            cin >> act[i].st >> act[i].ed;
            act[i].len = act[i].ed - act[i].st; // 计算活动时长
        }
        sort(act, act + n, [](tim x, tim y)
             { return (x.st < y.st); }); // 按起始时间从小到大排序
        int cst = act[0].st;
        int ced = act[0].ed;
        num++;
        for (int i = 1; i < n; i++)
        {

            if (act[i].st >= ced) // 活动开始时间大于当前截止时间
            {

                ced = act[i].ed; // 则向后增加一个活动，并更新当前截止时间
                num++;
            }
            else
            {
                if (act[i].ed < ced) // 活动的截止时间小于当前截止时间
                {
                    ced = act[i].ed; // 则更新
                }
            }
        }
        cout << num << endl;
    }
}

 

算法流程如下：

• 使用dfs遍历字符串s。
• 当遇到'['时，递归调用dfs函数。
• 当遇到']'时，返回结果。
• 否则将字符加入答案。

• #include <bits/stdc++.h>
  using namespace std;
  
  string dfs(string &s, int &i)
  {
      string ans;
      char c;
      while (i < s.size())
      {
          c = s[i++];
          if (c == '[')
          {
              int num;
              num = 0;
              while (isdigit(s[i]))
              {
                  num = num * 10 + (s[i++] - '0');
              }
              string s2 = dfs(s, i);
              while (num--)
              {
                  ans += s2;
              }
          }
          else if (c == ']')
          {
              return ans;
          }
          else
          {
              ans += c;
          }
      }
      return ans;
  }
  
  int main()
  {
      string s;
      cin >> s;
      int i = 0;
      cout << dfs(s, i);
      return 0;
  }

 

 

#include <bits/stdc++.h>
using namespace std;
const int Max = 1e6 + 5;
int n;
int a[Max], b[Max];
int lena, lenb, lenss;
int ss[Max];
struct T5
{
    long long l, r;
    bool operator<(T5 b)
    {
        return l * r < b.l * b.r;
    }
} d[1005];

void mulit(long long canshu)
{ // 高精度乘
    int x = 0;
    for (int i = 1; i <= lena; i++)
    {
        a[i] = a[i] * canshu + x;
        x = a[i] / 10;
        a[i] %= 10;
    }
    while (x)
    {
        a[++lena] = x % 10;
        x /= 10;
    }
}

void dive(long long canshu)
{ // 高精度除
    int n = lena;
    int now = 0;
    while (n > 0)
    {
        now = now * 10 + a[n];
        b[n] = now / canshu;
        now = now % canshu;
        n--;
    }
    lenb = lena;
    while (b[lenb] == 0 && lenb)
        lenb--;
}

void compare()
{
    int vis = 0;
    if (lenss < lenb)
        vis = 1;
    if (lenss == lenb)
    {
        for (int i = lenb; i >= 1; i--)
        {
            if (b[i] > ss[i])
            {
                vis = 1;
                break;
            }
            if (ss[i] > b[i])
                break;
        }
    }
    if (vis == 1)
    {
        for (int i = lenb; i >= 1; i--)
        {
            ss[i] = b[i];
        }
        lenss = lenb;
    }
}

int main()
{
    cin >> n;
    cin >> d[0].l >> d[0].r;
    for (int i = 1; i <= n; i++)
    {
        cin >> d[i].l >> d[i].r;
    }
    sort(d + 1, d + n + 1);
    int hl = d[0].l;
    while (hl)
    {
        a[++lena] = hl % 10;
        hl /= 10;
    }

    for (int i = 1; i <= n; i++)
    {

        dive(d[i].r);
        compare();
        mulit(d[i].l);
    }
    for (int i = lenss; i >= 1; i--)
    {
        cout << ss[i];
    }
}