2014蓝桥模拟赛预赛

1.标题：正则表示

    正则表达式表示了串的某种规则或规律。恰当地使用正则表达式，可以使得代码简洁、事半功倍。java的很多API都支持正则表达式作为参数。其中的String.split就是这样。

    看下面的代码，其意图为把一个或多个空格或逗号、句号分开的单词分离出来。即获得数组为：
    
    ["cat","doc","desk","push","last","this","is","what","must","be"]
    
    请在划线处填入适当代码，取得要求的效果。

    String s = "cat dog,desk push last,   this is what.   must be";

    String[] ss = s.split("___________________________");   //填空位置

    for(String k: ss) System.out.println(k);


请严格按照格式，通过浏览器提交答案。
注意：只提交划线部分缺少的内容，不要写其它附加内容，比如：说明性的文字或已经存在的代码。

//for each循环真的很方便！学起来啊大傻子！

2.题目标题: 堆煤球

    小明的爷爷很怀旧，冬天来了他还是要自己做煤球。

    并且，爷爷把煤球堆放得十分整齐有规律：最上边一层只有1个煤球。第二层4个煤球摆成正方形，再下面9个煤球也是摆成正方形。总之，第 n 层就是边长为 n 的正方形。这样的结构既通风又稳固。

    小明数了数，一共有30层，请你帮助计算一下，一共有多少个煤球？ ___________


请通过浏览器提交答案。
注意：只提交数字，不要求解过程或公式。
注意：不要书写其它的内容（比如：说明性的文字）。

3.题目标题: 大小之差

    某6位数，只包含1~9中的某些数字(可以重复包含同一数字，但不含数字0)。
    该数字重新排列数位后，可以得到最大数和最小数。最大最小之差也是6位数，并且它恰好包含了组成原6位数同样的数字。

    比如：766431 - 134667 = 631764 就是具有这样特征的数字。
    
    你还能找到另一个这样的6位数吗？
    
    请填写它重新排列数位后的得到的最大数：________________  


请通过浏览器提交答案。
注意：只提交另一个6位数，题中已经给出的这个不要提交。
注意：不要书写其它的内容（比如：说明性的文字）。

4.标题：回文数字

    观察数字：12321，123321 都有一个共同的特征，无论从左到右读还是从右向左读，都是相同的。这样的数字叫做：回文数字。

    本题要求你找到一些5位或6位的十进制数字。满足如下要求：
    该数字的各个数位之和等于输入的整数。


【输入格式】
一个正整数 n (10<n<100), 表示要求满足的数位和。

【输出格式】
若干行，每行包含一个满足要求的5位或6位整数。
数字按从小到大的顺序排列。
如果没有满足条件的，输出：-1

【样例输入】
44

【样例输出】
99899
499994
589985
598895
679976
688886
697796
769967
778877
787787
796697
859958
868868
877778
886688
895598
949949
958859
967769
976679
985589
994499

【样例输入2】
60

【样例输出2】
-1

【资源约定】
    峰值内存消耗 < 64M
    CPU消耗  < 1000ms



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

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

5.标题：最大子阵

    给定一个n*m的矩阵A，求A中的一个非空子矩阵，使这个子矩阵中的元素和最大。

    其中，A的子矩阵指在A中行和列均连续的一块。

【输入格式】
    输入的第一行包含两个整数n, m，分别表示矩阵A的行数和列数。
    接下来n行，每行m个整数，表示矩阵A。

【输出格式】
    输出一行，包含一个整数，表示A中最大的子矩阵中的元素个数。

【样例输入】
3 3
-1 -4 3
3 4 -1
-5 -2 8

【样例输出】
10

【样例说明】
取最后一列，和为10。

【数据规模与约定】
对于50%的数据，1<=n, m<=50；
对于100%的数据，1<=n, m<=500，A中每个元素的绝对值不超过5000。


【资源约定】
    峰值内存消耗 < 64M
    CPU消耗  < 3000ms

1.//一开始没有考虑到多个空格的情况，用了"[\\p{Punct}[' ']]"等别的方法，其实再加一个+就可以了

key："[\\p{Punct}[' ']]+"

或者简单的"[,.' ']+"

后来看到老师发的答案上写的是"( |,|\\.)+"，感觉括号还是没有方括号方便

2.9455

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int h=0;
        for(int i=1;i<n;i++){
            h+=i;
        }
        System.out.println(h);
    }

}

3.立刻想到自己昨天讲给我同学的“带分数”这一题，应该dfs所有可能的六位数，但是这个工作量太大了，可以重复，后面还有求最大最小值差，那个数也要是包含在那几个数字的...可能有更好的方法吧

4.import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=1;i<10;i++){
            for(int j=0;j<10;j++){
                for(int z=0;z<10;z++){
                    if(i*2+j*2+z==n)
                        System.out.println(""+i+j+z+j+i);
                }
            }
        }
        for(int i=1;i<10;i++){
            for(int j=0;j<10;j++){
                for(int z=0;z<10;z++){
                    if(i*2+j*2+z*2==n)
                        System.out.println(""+i+j+z+z+j+i);
                }
            }
        }
    }

}

5.//dp，从网上copy的，要注意数组一定要开到最大，不然运行会数组越界。

//由于行、列必须是连续的，所以可以先求出每一列前n行的和，然后再枚举一个 行的开始和结束就可以啦，然后再用最大字段和求出最大和。本质是将二维的转化为一维的。

import java.util.Scanner;
public class Main {
    public static int n;
    public static int m;
    public final static int MAXN=505;
    public static int dp_sum(int []tem){
        int ret=tem[1];
        int[] dp=new int[MAXN];
        for(int i=1;i<=n;i++){
            dp[i]=Math.max(tem[i],dp[i-1]+tem[i]);
            ret=Math.max(dp[i],ret);
        }
        return ret;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        int [][]num=new int[MAXN][MAXN];
        int [][]sum=new int[MAXN][MAXN];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                num[i][j]=sc.nextInt();
                sum[i][j]=sum[i-1][j]+num[i][j];
            }
        int maxnum=num[1][1];
        for(int i=1;i<=n;i++)
            for(int j=i;j<=n;j++){
                int[] tem=new int[MAXN];
                for(int k=1;k<=m;k++)
                    tem[k]=sum[j][k]-sum[i-1][k];
                maxnum=Math.max(maxnum,dp_sum(tem));
            }
        System.out.println(maxnum);
    }

}

之后在老师给的word里看到另一个方法，但是也太简单了吧...不可能吧，怎么可能求最大子阵就是找出来最大的那一行或者那一列呢，虽然好像题目也是这么说的，但是这是子阵诶...

import java.util.Scanner;

public class Main{

       publicstatic void main(String[] args) {

              Scannersc = new Scanner(System.in);

              intn = sc.nextInt();

              intm = sc.nextInt();

              inta[][] = new int[n][m];

              intsum[] = new int[2 * n * m];

              for (int i = 0; i < 2 * n * m;i++) {

                     sum[i] = 0;

              }

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

                     for (int j = 0; j < m;j++) {

                            a[i][j] =sc.nextInt();

                     }

              }

              int c = 0;

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

                     for (int j = 0; j < m;j++) {

                            sum[c] += a[i][j];

                     }

                     c++;

              }

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

                     for (int j = 0; j < m;j++) {

                            sum[c] += a[j][i];

                     }

                     c++;

              }

              intmm=sum[0];

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

                     mm=Math.max(mm, sum[i]);

              }

              System.out.println(mm);

}}