蓝桥杯最终冲刺（冲刺Day1）

 1.空间

 本题主要考察单位转换：

1MB=1024KB

    1KB=1024B

    1B=8b;

    B:byte字节

   b:bit比特(1位=1比特)

    32位=4B

    题解的意思是有多少个32位

    转化成long long避免数据溢出

所以不多废话，直接上代码

#include <iostream>
using namespace std;
int main()
{
  // 请在此输入您的代码
    //1MB=1024KB
    //1KB=1024B
    //1B=8b;
    //B:byte字节
    //b:bit比特(1位=1比特)
    //32位=4B
    //题解的意思是有多少个32位
    //转化成long long避免数据溢出
    cout<<(long long)256*1024*1024*8/32;
  return 0;
}

2. 等差数列

 

 

 

把给出的n个数据从小到大排序，然后求出n-1个差，再把差排序。

• 如果最小的差为0，那么公差必然为0，即有n个数。

• 最小的差不为零，那就求所有差的最大公约数Gcd，（差最大，数列才最短）。最少元素数 =(a_max - a_min )/ Gcd+1

#include <iostream>
#include <algorithm> 
using namespace std;
long long a[100001];
int y(int a,int b)//求最大公约数
{
  if(b==0)return a;
    else
  return y(b,a%b);
}
int main()
{
    int n,i;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    sort(a,a+n);//排序
    int d=a[1]-a[0];
    for(int i=2;i<n;i++)
    {
        d=y(d,a[i]-a[i-1]);
    }
    if(a[n-1]==a[0])cout<<n<<endl;//考虑特殊情况
    else
    cout<<((a[n-1]-a[0])/d)+1<<endl;//等差数列公式
    return 0;
}

 3.回文日期

 

 该题直接暴力破解

#include <iostream>
using namespace std;
 
int months[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(int y, int m, int d) //判断是否是合法日期
{
    if (d <= 0 || m <= 0 || m >= 13) return false;
    if (m != 2) 
    {
        if (d > months[m]) return false;
    }
    else
    {
        int days = months[2] + (y % 4 == 0 && y % 100 != 0 || y % 400 == 0);
        if (d > days) return false;
    }
    
    return true;
}
 
int flip(int x)
{
    int res = 0;
    while (x)
    {
        res = res * 10 + x % 10;
        x /= 10;
    }
    return res;
}
 
bool st1, st2;
int ans1, ans2;
 
int main()
{
    int n;
    cin >> n;
    
    for (int i = n + 1; i <= 89991231; i++)
    {
        int year = i / 10000, month = i % 10000 / 100, day = i % 100;
        if (check(year, month, day))
        {
            if (i % 10000 == flip(year) && !st1) 
                st1 = true, ans1 = i;
            
            if (i % 10000 == flip(year) && (month / 10 == day / 10) && (month % 10 == day % 10) && !st2) 
                st2 = true, ans2 = i;
        }
        
        if (st1 && st2) break;
    }
    
    printf("%d\n%d\n", ans1, ans2);
    return 0;
}

 

 4.成绩统计

思路：我们选择使用printf来输出答案，把得出来的整数型换成浮点再输出。 

#include <iostream>
using namespace std;
#include<cstdio>
int main()
{
    int num;
    int cj;
    int jig = 0;
    int youx = 0;
    double jigl;
    double youxl;
    cin>>num;
  for(int i = 1;i<=num;i++){
      cin>>cj;
      if(cj>=60){
          jig++;
      }
        if(cj>=85){
          youx++;
      }
  }
      
  jigl = 100.0*jig/num;
  youxl =100.0*youx/num;
  printf("%.0lf%\n",jigl);
  printf("%.0lf%\n",youxl);
  
  
  return 0;
}

5.既约分数 

 

 直接用欧几里得求就好了，这是简单数论，直接上代码

#include <iostream>
using namespace std;

//欧几里得算法求最大公约数
int gcd(int a,int b)
{
  if(a<b)
  {
    swap(a,b);
  }
  if(a%b == 0)
  {
    return b;
  }
  return gcd(b,a%b);
}

int main()
{
  int a,b,i = 0;
  for(a=1;a<=2020;a++)
  {
    for(b=1;b<=2020;b++)
    {
      if(gcd(a,b) == 1)
      {
        i++;
      }
    }
  }

  cout<<i<<endl;

  return 0;
}

 6.最优包涵

 

 由于可以组成特别多的序列，因此我们使用动态规划思想来简化该过程。
我们设dp[i][j]表示S串中前i个字符，包含有T串中前j个字符最少需要修改的字符个数。

因此分析得到：
如果S[i]=T[j] ,那么T串中的最后一位要么让他和S[i]相等，要么让他和前面的相等。
dp[i][j] = min(dp[i-1][j],dp[i-1][j-1]);

如果S[i]!=T[j],那么要么是让T[j]和S串前面的字符一样，要么修改S[i]。
dp[i][j]= min(dp[i-1][j-1]+1,dp[i-1][j])

并且注意的是这里动态方程中我们的i，j为个数的意思，转换为代码时由于下标从0开始，所以实际上要大一。

 

#include <iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{

  string S,T;
  cin>>S;
  cin >>T;
  int len1 = S.size(),len2 = T.size();

  vector<vector<int>> dp(len1+1,vector<int>(len2+1,0));
  if(S[0]==T[0]){
    dp[1][1] = 0;
  }else{
    dp[1][1] = 1;
  }
  for(int i=2;i<=len1;++i){
    if(S[i-1] == T[0]){
      dp[i][1] = 0;
    }else{
      dp[i][1] = dp[i-1][1];
    }
  }

  for(int i=2;i<=len1;++i){
    for(int j=2;j<=i && j<=len2;++j){
      if(S[i-1]==T[j-1]){
        dp[i][j] = dp[i-1][j-1];
      }else{
        dp[i][j] = dp[i-1][j-1] + 1;
        for(int k=j;k<i;++k){
          dp[i][j] = min(dp[i][j],dp[k][j]);
        }
      }
    }
  }

  cout <<dp[len1][len2] <<endl;
  
  return 0;
}