第十二届蓝桥杯模拟赛（第三期）

第十二届蓝桥杯模拟赛（第三期）

无脑暴力 有错误望指正

问题描述
　　给定一个矩阵 M，由 n 行 m 列组成，第 i 行第 j 列值为 M[i][j]。
　　定义矩阵 M 的重量为矩阵中所有元素的和，几位weight(M)
　　请找到矩阵左上角的一个子矩阵S（矩阵的前 r 行中的前 c 列组成），使得这个子矩阵的重量的两倍最接近矩阵 M 重量。即 |2 weight(S)-weight(M)| 最小。
　　如果有多个子矩阵满足条件，请找出面积 r * c 最小的一个。
　　如果仍然有多个子矩阵满足条件，请找出其中 r 最小的一个。
输入格式
　　输入第一行包含两个整数 n, m，表示矩阵的大小。
　　接下来 n 行，每行 m 个整数，表示给定的矩阵M。
输出格式
　　输出一行，包含两个整数 r, c，表示子矩阵为矩阵 M 的前 r 行中的前 c 列。
样例输入
3 4
3 0 1 1
1 0 1 1
1 1 -2 4
样例输出
2 3
数据规模和约定
　　对于 30% 的评测用例，1 <= n, m <= 20, -10 <= M[i][j] <= 10。
　　对于 50% 的评测用例，1 <= n, m <= 100, -100 <= M[i][j] <= 100。
　　对于所有评测用例，1 <= n, m <= 1000, -1000 <= M[i][j] <= 1000。

package com.xu.LanqiaoMoni;

import java.util.Scanner;

public class Main9 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int hang=sc.nextInt();
        int lie=sc.nextInt();
        int arr[][]=new int [hang][lie];
        for (int i=0;i<hang;i++){
            for (int j=0;j<lie ;j++){
                arr[i][j]=sc.nextInt();
            }
        }

    abs(arr,hang,lie);

    }
    //求出矩阵之和
    public  static  int sum(int[][] arr,int hang,int lie){
        int sum=0;
        for (int i=0;i<hang;i++){
            for (int j=0;j<lie ;j++){
                sum+=arr[i][j];
            }
        }
        return sum;
    }
    //求出最小的重量差的 r c
    public static  void abs(int[][] arr,int hang,int lie){
        int temp,num=0;
        int a=0;
        int b=0;
        for (int r=0;r<hang;r++){
            for (int c=0;c<lie;c++){
                Math.abs(2*sum(arr,r,c)-sum(arr,hang,lie));
                if (num==0){
                    num= Math.abs(2*sum(arr,r,c)-sum(arr,hang,lie));
                    a=r;
                    b=c;
                }else {
                    temp= Math.abs(2*sum(arr,r,c)-sum(arr,hang,lie));
                    if (num>temp){
                        num=temp;
                        a=r;
                        b=c;
                    }
                }
            }
        }
        System.out.printf("%d %d",a,b);
    }

}

问题描述
　　杂货铺老板一共有N件物品，每件物品具有ABC三种属性中的一种或多种。从杂货铺老板处购得一件物品需要支付相应的代价。
　　现在你需要计算出如何购买物品，可以使得ABC三种属性中的每一种都在至少一件购买的物品中出现，并且支付的总代价最小。
输入格式
　　输入第一行包含一个整数N。
　　以下N行，每行包含一个整数C和一个只包含"ABC"的字符串，代表购得该物品的代价和其具有的属性。
输出格式
　　输出一个整数，代表最小的代价。如果无论如何凑不齐ABC三种属性，输出-1。
样例输入
5
10 A
9 BC
11 CA
4 A
5 B
样例输出
13
数据规模和约定
　　对于50%的评测用例，1 <= N <= 20
　　对于所有评测用例，1 <= N <= 1000， 1 <= C <= 100000

package com.xu.LanqiaoMoni;

import java.util.Scanner;

public class Main10 {
   public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);
       int length=sc.nextInt();
       int arr[]=new int[length];
       String string[]=new String[length];
       for (int i=0;i<length;i++){
           arr[i]=sc.nextInt();
           string[i]=sc.next();
       }
       System.out.println(check(string,arr));
   }
   public static int check(String[]strings,int[]arr){
      int temp=0;
      int num=0;
       for (int i=0;i<strings.length-1;i++){
           for (int j=i+1;j<strings.length;j++){
               if (judge(strings[i]+strings[j])){
                   if (num==0){
                       num=arr[i]+arr[j];
                   }else {
                       temp=arr[i]+arr[j];
                       if (temp<num){
                          num=temp;
                       }
                   }
               }
           }
       }
       return num;
   }
   public  static boolean judge(String str){
       if (str.contains("A")&&str.contains("B")&&str.contains("C")&&str.length()==3){
           return true;
       }else {
           return false;
       }
   }
}

问题描述
　　斐波那契数列是这样一个数列：它的第一项和第二项都是1，从第三项开始每一项都是前两项的和。
　　根据以上定义，我们容易计算出斐波那契数列的前几项依次是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ……
　　现在请你计算斐波那契数列第N项是奇数还是偶数？
输入格式
　　输入的包含一个整数N。
输出格式
　　如果是奇数输出1，是偶数输出0。
样例输入
10
样例输出
1
提示
　　找规律。
数据规模和约定
　　对于所有评测用例，1 <= N <= 1000000000。

package com.xu.LanqiaoMoni;


import java.util.Scanner;

public class Main8 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
       int a= sc.nextInt();
       if (check(a)%2==0){
           System.out.println(0);
       }else {
           System.out.println(1);
       }
    }
    //先求出数列的第N位是什么

    public  static  int check(int a){
        int number=0;
        if (a==1||a==2){
            number=1;
        }else {
            number=check(a-1)+check(a-2);
        }
        return number;
    }
}

问题描述
　　在书写一个较大的整数时，为了方便看清数位，通常会在数位之间加上逗号来分割数位，具体的，从右向左，每三位分成一段，相邻的段之间加一个逗号。
　　例如，1234567 写成 1,234,567。
　　例如，17179869184 写成 17,179,869,184。
　　给定一个整数，请将这个整数增加分割符后输出。
输入格式
　　输入一行包含一个整数 v。
输出格式
　　输出增加分割符后的整数。
样例输入
1234567
样例输出
1,234,567
样例输入
17179869184
样例输出
17,179,869,184
数据规模和约定
　　对于 50% 的评测用例，0 <= v < 10^9 (10的9次方)。
　　对于所有评测用例，0 <= v < 10^18 (10的18次方)。

package com.xu.LanqiaoMoni;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main6 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        String str=sc.next();
        StringBuilder stringBuilder=new StringBuilder(str);
        System.out.println(stringBuilder);
        str=stringBuilder.reverse().toString();
        System.out.println(str);

        char[]chars=str.toCharArray();
        String[]strings=str.split("");
        List<String>test=new ArrayList<String>();
        for (int i=0;i<strings.length;i++){
            test.add(strings[i]);
          if (test.size()%3==0&&i+1<strings.length){
              strings[i+1]=","+strings[i+1];
          }
        }
        String ss="";
        for (String s:test) {
           ss+=s;
        }
        StringBuilder stringBuilder2=new StringBuilder(ss);
        System.out.println(stringBuilder2.reverse());

    }
}