算法笔记_213:第七届蓝桥杯软件类决赛部分真题（Java语言C组）

目录

1 平方末尾

2 七星填数

3 打印数字

4 赢球票

前言：以下代码仅供参考，若有错误欢迎指正哦~

---

1 平方末尾

平方末尾

能够表示为某个整数的平方的数字称为“平方数”
比如，25,64
虽然无法立即说出某个数是平方数，但经常可以断定某个数不是平方数。
因为平方数的末位只可能是：[0, 1, 4, 5, 6, 9] 这6个数字中的某个。
所以，4325435332必然不是平方数。

如果给你一个2位或2位以上的数字，你能根据末位的两位来断定它不是平方数吗？

请计算一下，一个2位以上的平方数的最后两位有多少种可能性？

注意：需要提交的是一个整数，表示2位以上的平方数最后两位的不同情况数。
不要填写任何多余内容（比如，说明解释文字等）

答案：22

 import java.util.HashSet;

 public class Main {
     public static HashSet<String> set = new HashSet<String>();

     public static void main(String[] args) {
         for(long i = 10;i <= 1000000;i++) {
             String a = "" + (i * i / 10 % 10) * 10 + "" +i * i % 10;
             set.add(a);
         }
         System.out.println(set.size());
     }
 }

---

2 七星填数

七星填数

如图【图1.png】所示。

在七角星的14个节点上填入1~14 的数字，不重复，不遗漏。
要求每条直线上的四个数字之和必须相等。

图中已经给出了3个数字。
请计算其它位置要填充的数字，答案唯一。

填好后，请提交绿色节点的4个数字（从左到右，用空格分开）

比如：12 5 4 8
当然，这不是正确的答案。

注意：只提交4个用空格分开的数字，不要填写任何多余的内容。

答案：10 3 9 8

 import java.util.HashSet;

 public class Main {
     public static int sum = 0;

     public void swap(int[] A, int i, int j) {
         int temp = A[i];
         A[i] = A[j];
         A[j] = temp;
     }

     public void dfs(int[] A, int step) {
         if(step == A.length) {
             int[] count = new int[7];
             count[0] = A[0] + A[1] + A[2] + A[3];
             count[1] = A[0] + A[4] + A[6] + A[9];
             count[2] = A[1] + A[4] + 6 + 14;
             count[3] = A[2] + A[5] + 6 + 11;
             count[4] = A[6] + A[8] + A[10] + 14;
             count[5] = A[7] + A[8] + A[9] + 11;
             count[6] = A[3] + A[5] + A[7] + A[10];
             HashSet<Integer> set = new HashSet<Integer>();
             for(int i = 0;i < 7;i++)
                 set.add(count[i]);
             if(set.size() == 1) {
                 for(int i = 0;i < A.length;i++)
                     System.out.print(A[i]+" ");
                 System.out.println();
             }
             sum++;
             return;
         } else {
             for(int i = step;i < A.length;i++) {
                 swap(A, i, step);
                 dfs(A, step + 1);
                 swap(A, i, step);
             }
         }
     }

     public static void main(String[] args) {
         Main test = new Main();
         int[] A = {1,2,3,4,5,7,8,9,10,12,13};
         test.dfs(A, 0);
         System.out.println(sum);
     }
 }

---

3 打印数字

打印数字

小明写了一个有趣的程序，给定一串数字。
它可以输出这串数字拼出放大的自己的样子。

比如“2016”会输出为：
 22222   00000       1   6666
2     2 0     0    1 1  6
      2 0     0      1  666666
     2  0     0      1  6     6
   2    0     0      1  6     6
 2    2 0     0      1  6     6
2222222  00000     1111  66666

请仔细分析代码，填写划线部分缺少的内容。

public class Main
{
    static void f(int n)
    {
        String[][] di =
    {{" 00000 ",
    "0     0",
    "0     0",
    "0     0",
    "0     0",
    "0     0",
    " 00000 "},
    {"     1 ",
    "   1 1 ",
    "     1 ",
    "     1 ",
    "     1 ",
    "     1 ",
    "   1111"},
    {" 22222 ",
    "2     2",
    "      2",
    "     2 ",
    "   2   ",
    " 2    2",
    "2222222"},
    {" 33333 ",
    "3     3",
    "      3",
    "  3333 ",
    "      3",
    "3     3",
    " 33333 "},
    {"   44  ",
    "  4 4  ",
    " 4  4  ",
    "4   4  ",
    "4   4  ",
    "4444444",
    "    4  "},
    {" 55555 ",
    " 5     ",
    "555555 ",
    "      5",
    "      5",
    "5     5",
    " 55555 "},
    {" 6666  ",
    "6      ",
    "666666 ",
    "6     6",
    "6     6",
    "6     6",
    " 66666 "},
    {"7777777",
    "7    7 ",
    "    7  ",
    "   7   ",
    "  7    ",
    " 7     ",
    " 7     "},
    {" 88888 ",
    "8     8",
    "8     8",
    " 88888 ",
    "8     8",
    "8     8",
    " 88888 "},
    {" 99999 ",
    "9     9",
    "9     9",
    " 999999",
    "      9",
    "9     9",
    " 99999 "}};

        char[] cc = (""+n).toCharArray(); 

        for(int i=0; i<di[0].length; i++){
            for(int j=0; j<cc.length; j++){
                System.out.print( ____________________ + " ");  //填空位置
            }
            System.out.println();
        }
    }

    public static void main(String[] args)
    {
        f(2016);
    }
}

注意：只提交划线部分缺少的代码，不要添加任何题面已有代码或符号。
也不要提交任何说明解释文字等。

答案：di[cc[j]-'0'][i]

---

4 赢球票

赢球票

某机构举办球票大奖赛。获奖选手有机会赢得若干张球票。

主持人拿出 N 张卡片（上面写着 1~N 的数字），打乱顺序，排成一个圆圈。
你可以从任意一张卡片开始顺时针数数: 1,2,3.....
如果数到的数字刚好和卡片上的数字相同，则把该卡片收入囊中，从下一个卡片重新数数。
直到再无法收获任何卡片，游戏结束。囊中卡片数字的和就是赢得球票的张数。

比如：
卡片排列是：1 2 3
我们从1号卡开始数，就把1号卡拿走。再从2号卡开始，但数的数字无法与卡片对上，
很快数字越来越大，不可能再拿走卡片了。因此这次我们只赢得了1张球票。

还不算太坏！如果我们开始就傻傻地从2或3号卡片数起，那就一张卡片都拿不到了。

如果运气好，卡片排列是 2 1 3
那我们可以顺利拿到所有的卡片！

本题的目标就是：已知顺时针卡片序列。
随便你从哪里开始数，求最多能赢多少张球票（就是收入囊中的卡片数字之和）

输入数据：
第一行一个整数N(N<100)，表示卡片数目
第二行 N 个整数，表示顺时针排列的卡片

输出数据：
一行，一个整数，表示最好情况下能赢得多少张球票

比如：
用户输入：
3
1 2 3

程序应该输出：
1

比如：
用户输入：
3
2 1 3

程序应该输出：
6

资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

 import java.util.Scanner;

 public class Main {
     public static int n;
     public static int max = 0;
     public static int[] value;

     public void getResult() {
         for(int i = 0;i < n;i++) {
             int[] temp = new int[n];
             for(int k = 0;k < n;k++)
                 temp[k] = value[k];
             int sum = 0;
             int count = 1;
             int start = i;
             while(true) {
                 boolean judge = true;
                 for(int k = 0;k < n;k++)
                     if(temp[k] >= count) {
                         judge = false;
                         break;
                     }
                 if(judge)
                     break;
                 int j = start % n;
                 if(temp[j] == count) {
                     sum = sum + count;
                     temp[j] = -1;
                     count = 1;
                 } else if(temp[j] != -1)
                     count++;
                 start++;
             }
             max = Math.max(max, sum);
         }
         System.out.println(max);
     }

     public static void main(String[] args) {
         Main test = new Main();
         Scanner in = new Scanner(System.in);
         n = in.nextInt();
         value = new int[n];
         for(int i = 0;i < n;i++)
             value[i] = in.nextInt();
         test.getResult();
     }
 }