蓝桥杯赛前冲刺30天打卡题解(Day2)

一、排它平方数

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

小明正看着 203879203879 这个数字发呆。

原来,203879 * 203879 = 41566646641203879∗203879=41566646641。

这有什么神奇呢?仔细观察,203879203879 是个 66 位数,并且它的每个数位上的数字都是不同的,并且它平方后的所有数位上都不出现组成它自身的数字。

具有这样特点的 66 位数还有一个,请你找出它!

再归纳一下筛选要求:

  1. 66 位正整数;
  2. 每个数位上的数字不同;
  3. 其平方数的每个数位不含原数字的任何组成数位。

 思路1:先定义俩个数组a和b,存放(这个六位数和它的平方)的每一位数,然后先判断这个六位数是否每个数位上的数字不同,再判断其平方数的每个数位不含原数字的任何组成数位。

思路2:暴力解决一切花里胡哨

 解答一:暴力

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int a[5], b[12];
  long long i, t, j, k, n, m;
  int flag;
  for(i = 100000; i <= 999999; i++)
  {
    flag = 1;
    t = i * i;
    a[0] = i % 10;
    a[1] = i % 100 / 10;
    a[2] = i % 1000 / 100;
    a[3] = i % 10000 / 1000;
    a[4] = i % 100000 / 10000;
    a[5] = i % 1000000 / 100000;
    if(i <= 316227)
    {
      b[0] = t % 10;
      b[1] = t % 100 / 10;
      b[2] = t % 1000 / 100;
      b[3] = t % 10000 / 1000;
      b[4] = t % 100000 / 10000;
      b[5] = t % 1000000 / 100000;
      b[6] = t % 10000000 / 1000000;
      b[7] = t % 100000000 / 10000000;
      b[8] = t % 1000000000 / 100000000;
      b[9] = t % 10000000000 / 1000000000;
      b[10] = t % 100000000000 / 10000000000;
    }
    else
    {
      b[0] = t % 10;
      b[1] = t % 100 / 10;
      b[2] = t % 1000 / 100;
      b[3] = t % 10000 / 1000;
      b[4] = t % 100000 / 10000;
      b[5] = t % 1000000 / 100000;
      b[6] = t % 10000000 / 1000000;
      b[7] = t % 100000000 / 10000000;
      b[8] = t % 1000000000 / 100000000;
      b[9] = t % 10000000000 / 1000000000;
      b[10] = t % 100000000000 / 10000000000;
      b[11] = t % 1000000000000 / 100000000000;
    }
    for(j = 0; j <= 5; j++)
    {
      for(k = j + 1; k <= 5; k++)
      {
        if(a[j] == a[k])
          flag = 0;
      }
    }
    n = 0;
    for(n = 0; n <= 5; n++)
    {
      for(m = 0; m <= 11; m++)
      {
        if(a[n] == b[m])
        {
          flag = 0;
        }
      }
    }
    if(flag == 1)
      break;
  }
  printf("%lld", i);
  return 0;
}

 PS:暴力在检测时不通过,原因为:运行时间太长,所以我们要换第二种思路

#include <stdio.h>
#include <stdlib.h>
int check(long long x, long long xx)
{
    int i, j;
    char str1[10];
    char str2[20];
    sprintf(str1, "%lld", x);
    sprintf(str2, "%lld", xx);
    for (i = 0; str1[i] != '\0'; i++) 
    {
        for (j = 0; str2[j] != '\0'; j++)
        {
            if (str1[i] == str2[j])
                return 0;
        }
    }
    return 1;
}

int main() 
{
  long long a, b, c, d, e, f;
  for (a = 1; a < 10; a++) 
  {
    for (b = 0; b < 10; b++) 
    {
      if (b != a)
        for (c = 0; c < 10; c++) 
        {
          if (c != a && c != b)
            for (d = 0; d < 10; d++) 
            {
              if (d != a && d != b && d != c)
                for (e = 0; e < 10; e++) 
                {
                  if (e != a && e != b && e != c && e != d)
                    for (f = 0; f < 10; f++) 
                    {
                      if (f != a && f != b && f != c && f != d && f != e) 
                      {
                        long long x = a * 100000 + b * 10000 + c * 1000 + d * 100 + e * 10 + f;
                        if (check(x, x * x) && x != 203879) 
                        {
                          printf("%lld", x);
                        }
                      }
                    }
                }
            }
        }
    }
  }
  return 0;
}

 二、买不到的数目

 小明开了一家糖果店。他别出心裁:把水果糖包成 4 颗一包和 7 颗一包的两种。糖果不能拆包卖。
小朋友来买糖的时候,他就用这两种包装来组合。当然有些糖果数目是无法组合出来的,比如要买 10 颗糖。
你可以用计算机测试一下,在这种包装情况下,最大不能买到的数量是 17。大于 17 的任何数字都可以用 4 和 7 组合出来。
本题的要求就是在已知两个包装的数量时,求最大不能组合出的数字。


输入描述
输入两个正整数,表示每种包装中糖的颗数(都不多于 1000 )。
输出描述
输出一个正整数,表示最大不能买到的糖数。
不需要考虑无解的情况
输入输出样例
输入
4 7
输出
17

 思路:核心利用:两个数a和b,如果互质,那么最大不能组成的数是a*b-a-b。

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int a, b;
  scanf("%d %d", &a, &b);
  printf("%d", a * b - a - b);
  return 0;
}

 三、回文日期

 2020 年春节期间,有一个特殊的日期引起了大家的注意:2020 年 2 月 2 日。因为如果将这个日期按 “yyyymmdd” 的格式写成一个 8 位数是 20200202,恰好是一个回文数。我们称这样的日期是回文日期。
有人表示 20200202 是 “千年一遇” 的特殊日子。对此小明很不认同,因为不到 2 年之后就是下一个回文日期:20211202 即 2021 年 12 月 2 日。
也有人表示 20200202 并不仅仅是一个回文日期,还是一个 ABABBABA 型的回文日期。对此小明也不认同,因为大约 100 年后就能遇到下一个 ABABBABA 型的回文日期:21211212 即 2121 年 12 月 12 日。算不上 “千年一遇”,顶多算 “千年两遇”。
给定一个 8 位数的日期,请你计算该日期之后下一个回文日期和下一个 ABABBABA 型的回文日期各是哪一天。
 

输入描述
输入包含一个八位整数 N,表示日期。
对于所有评测用例,10000101 ≤ N ≤ 89991231,保证 N 是一个合法日期的 8 位数表示。
输出描述
输出两行,每行 1 个八位数。第一行表示下一个回文日期,第二行表示下一个 ABABBABA 型的回文日期。
输入输出样例
输入
20200202
输出
20211202
21211212
 

 这道题,直接暴力就完事了。下面给上代码

 

#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;
}

 

四、约瑟夫环

n 个人的编号是 1 ~ nn,如果他们依编号按顺时针排成一个圆圈,从编号是 1 的人开始顺时针报数。
(报数是从 1 报起)当报到 kk 的时候,这个人就退出游戏圈。下一个人重新从 1 开始报数。
求最后剩下的人的编号。这就是著名的约瑟夫环问题。
本题目就是已知 n,kn,k 的情况下,求最后剩下的人的编号。
 

输入描述
输入是一行,2 个空格分开的整数 n, k(0 < n, k < 10的7次方)。
输出描述
要求输出一个整数,表示最后剩下的人的编号。
输入输出样例
输入
10 3
输出
4

道题是18年蓝桥杯国赛的真题,也是很经典的一道递归题。在CSDN上有很多大佬的讲解,我就直接上代码了。 

#include <stdio.h>
int main()
{
  int n,k,i,j=0;
  scanf("%d %d",&n,&k);
  for(i=1; i<=n; i++)
  {
    j=(j+k)%i;
  }
  j++;
  printf("%d",j);
  return 0;
}

今天的四道题,其实难度还是比较大的 ,希望大家可以持之以恒,新人创作不易,求个三连,蟹蟹~~

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
树上选点是蓝桥杯Java目中的一种类型,通常需要在给定的树结构中选择一个或多个节点作为目标节点,并进行相应的操作。下面是一个简单的树上选点蓝桥Java题解的示例: 目描述: 给定一棵有N个节点的树,每个节点上都有一个非负整数值。现在需要选择一些节点,使得选择的节点的值之和最大,且所选节点不能相邻(即选了一个节点,则其父节点和子节点都不能选)。请编写一个程序,计算出最大的节点值之和。 解思路: 这是一个典型的动态规划问。我们可以定义一个数组dp,其中dp[i]表示以第i个节点为根节点的子树中所选节点的最大值之和。对于每个节点i,有两种情况: 1. 选择节点i:则其子节点都不能选,所以dp[i] = val[i] + dp[grandchild1] + dp[grandchild2] + ... 2. 不选择节点i:则其子节点可以选择或不选择,所以dp[i] = max(dp[child1], dp[child2], ...) 根据以上思路,我们可以使用递归或者迭代的方式来计算dp数组。最终,所求的最大值即为dp,其中1表示根节点。 代码示例: ```java public class TreeSelectPoint { public static void main(String[] args) { int[] values = {0, 1, 2, 3, 4, 5}; // 节点值数组,下标从1开始 int[][] edges = {{1, 2}, {1, 3}, {2, 4}, {2, 5}}; // 树的边关系数组 int n = values.length - 1; // 节点个数 int[] dp = new int[n + 1]; // 动态规划数组 // 构建树的邻接表 List<List<Integer>> adjacencyList = new ArrayList<>(); for (int i = 0; i <= n; i++) { adjacencyList.add(new ArrayList<>()); } for (int[] edge : edges) { int u = edge[0]; int v = edge[1]; adjacencyList.get(u).add(v); adjacencyList.get(v).add(u); } dfs(1, -1, values, adjacencyList, dp); // 从根节点开始进行深度优先搜索 System.out.println(dp[1]); // 输出最大节点值之和 } private static void dfs(int cur, int parent, int[] values, List<List<Integer>> adjacencyList, int[] dp) { dp[cur] = values[cur]; // 初始化当前节点的dp值为节点值 for (int child : adjacencyList.get(cur)) { if (child != parent) { // 避免重复访问父节点 dfs(child, cur, values, adjacencyList, dp); dp[cur] += dp[child]; // 更新当前节点的dp值 } } } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小灰QAQ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值