第十届蓝桥杯题解

第十届蓝桥杯题解

A，组队

签到题

package train;

public class test_20 {
    public static void main(String []args){
        System.out.println(98+99+98+97+98);
    }
}

B，不同子串

先利用hashset，来填装不同的子串，在填装的过程中，利用到了subString来截取字符串

因为subString截取的区间是左闭右开，所以右区间要超出有效字符的一个长度，就是第二个for循环中的j取值要+1，

package train;

import java.util.HashSet;

public class test_21 {
    public static void main(String []args){
        HashSet<String> str=new HashSet<String>();
        String str1="0100110001010001";
        for(int i=0;i<str1.length();i++)
            for(int j=i+1;j<str1.length()+1;j++){
                str.add(str1.substring(i,j));
            }
      System.out.println(str.size());
    }
}

C，数列求值

因为最后只要最后四位数字，所以之保存最后四位数字，所以要和10000取余

package train;

public class test_22 {
    public static void main(String []args){
        int []a=new int[20190325];
        a[0]=1;a[1]=1;a[2]=1;a[3]=3;
        for(int i=4;i<20190324;i++){
            a[i]=(a[i-1]+a[i-2]+a[i-3])%10000;
        }
            System.out.println(a[20190323]);//4659
    }
}

D，数的分解

不知道在那个数字之后会有算式重复，所以干脆让他们三个数字是一个递增次序，这样就可以避免算式重复了，

package train;


public class test_23 {
    public static boolean ifs(int x) {
        String s = String.valueOf(x);
        if (s.contains("2") || s.contains("4"))
            return false;
        return true;
    }
    public static void main(String[] args){
       int ans=0;
        for(int i=1;i<2019;i++) {
            for (int j = i+1; j < 2019; j++) {
                int z=2019-i-j;
                if(i<j&&j<z) {
                    if (ifs(i) && ifs(j) && ifs(z)) {
                        ans++;
                    }
                }
            }
        }
        System.out.println(ans);
    }
}//40785

E，迷宫

采用bfs的方法，bfs层层遍历，且是字典序最小的路径，所以采用先D->L->R->U的查询次序

且需要打印路径，直接在node里面在搞一个String来保存每次的路径就可以了

package train;

import java.util.LinkedList;
import java.util.Queue;

class node{
    int x,y;
    String s;
    node(int x,int y,String s){
        this.x=x;this.y=y;this.s=s;
    }//用来记录访问的点
}
public class test_25 {
    public static int dis[][]={{1,0},{0,-1},{0,1},{-1,0}};//确定下左右上的方向
    public static char[][] g=new char[50][50];
    public static String[] nn= {
            "01010101001011001001010110010110100100001000101010",
            "00001000100000101010010000100000001001100110100101",
            "01111011010010001000001101001011100011000000010000",
            "01000000001010100011010000101000001010101011001011",
            "00011111000000101000010010100010100000101100000000",
            "11001000110101000010101100011010011010101011110111",
            "00011011010101001001001010000001000101001110000000",
            "10100000101000100110101010111110011000010000111010",
            "00111000001010100001100010000001000101001100001001",
            "11000110100001110010001001010101010101010001101000",
            "00010000100100000101001010101110100010101010000101",
            "11100100101001001000010000010101010100100100010100",
            "00000010000000101011001111010001100000101010100011",
            "10101010011100001000011000010110011110110100001000",
            "10101010100001101010100101000010100000111011101001",
            "10000000101100010000101100101101001011100000000100",
            "10101001000000010100100001000100000100011110101001",
            "00101001010101101001010100011010101101110000110101",
            "11001010000100001100000010100101000001000111000010",
            "00001000110000110101101000000100101001001000011101",
            "10100101000101000000001110110010110101101010100001",
            "00101000010000110101010000100010001001000100010101",
            "10100001000110010001000010101001010101011111010010",
            "00000100101000000110010100101001000001000000000010",
            "11010000001001110111001001000011101001011011101000",
            "00000110100010001000100000001000011101000000110011",
            "10101000101000100010001111100010101001010000001000",
            "10000010100101001010110000000100101010001011101000",
            "00111100001000010000000110111000000001000000001011",
            "10000001100111010111010001000110111010101101111000"};
    public static boolean [][]vis=new boolean[50][50];
    public static Queue<node> q=new LinkedList<>();
    public static char []zimu={'D','L','R','U'};
    public static void bfs(){
      q.add(new node(0,0,""));
      vis[0][0]=true;//先给队列添加一个元素，这是起点
      while(!q.isEmpty()) {
          node t = q.poll();//出队，并且返回一个值
          //队列中存储的都是node对象，
          for (int i = 0; i < 4; i++) {
              int tx = t.x + dis[i][0];
              int ty = t.y + dis[i][1];
              if (tx >= 0 && tx < 30 && ty >= 0 && ty < 50 && vis[tx][ty]==false && g[tx][ty] != '1') {
                  if (tx == 29 && ty == 49) {
                      System.out.println(t.s + zimu[i]);
                  } else {
                      vis[tx][ty] = true;
                      q.add(new node(tx, ty, t.s + zimu[i]));
                  }
              }
          }
      }
    }
    public static void main(String [] args){
        for(int i=0;i<30;i++)
            g[i]=nn[i].toCharArray();
        bfs();
    }
}

F，特别数的和

package train;

import java.util.Scanner;

public class test_24 {
    public static boolean ifs(int x){
        String str=String.valueOf(x);
        if(str.contains("2")||str.contains("0")||str.contains("1")||str.contains("9"))
            return true;
        return false;
    }
    public static void main(String[] args){
        int ans=0;
        Scanner br=new Scanner(System.in);
        int n=br.nextInt();
        for(int i=1;i<=n;i++){
            if(ifs(i))
                ans+=i;
        }
        System.out.println(ans);
    }
}

G，外卖店优先级

此题，只有40%的通过率，感觉把所有的情况都考虑了，不知道为什么，最后看了别人的题解，终于过了

40%：

package train;

import java.util.Scanner;

public class test_26 {
    public static void main(String[] args){
        Scanner br=new Scanner(System.in);
        int n,m,t;
        n=br.nextInt();
        m=br.nextInt();
        t=br.nextInt();
        int ts,id;
        int [][] nn=new int[n+1][t+1];
        while(m!=0){
            ts=br.nextInt();
            id=br.nextInt();
            nn[id][ts]++;
            m--;
        }
        int count=0;
        boolean [] f=new boolean[n+1];
        int [] gg=new int[n+1];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=t;j++){
                if(gg[i]>0&&nn[i][j]==0)
                    gg[i]-=1;
                if(nn[i][j]>0)
                    gg[i]+=2*nn[i][j];
                if(gg[i]>5) {
                    f[i]=true;
                }
            }

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

            if (gg[i] > 5 || (f[i] == true && gg[i] > 3))//两种情况，第一种是t时刻直接大于5，第二种就是在过程中有大于5的，但到最后
                count++;//又小于5，但是大于3的这样的同样没有被清除出优先缓存、
            System.out.println(gg[i]);
        }
         System.out.println(count);
    }
}

100%

import java.util.Scanner;


public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		int[][] arr1 = new int[m][2];//订单信息数组    行代表订单数    列代表订单信息(时间 t,店铺id n)
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr1[i].length; j++) {
				arr1[i][j]=sc.nextInt();//录入信息
			}
		}
		int[][] f = new int[n][2];//等级and状态数组  行代表每个店铺(店铺1对应下标0) 列代表等级状态信息(等级，状态(1为优先级,0不是优先级))  
		int[] sf = new int[n];//改动 标记 (店铺1对应下标0) 数据0代表未改动 1代表已经改动
		for (int i = 1; i <=t; i++) {//一秒一秒走：
			//循环订单 匹配时间
			for (int j = 0; j < m; j++) {
				if(i==arr1[j][0]){//如果在i时间里存在订单
					f[arr1[j][1]-1][0]+=2;//改变等级 
					sf[arr1[j][1]-1]=1;//改变标记
				}
			}
			//查看标记的状态 修改未被修改过的(在这一时间里不存在订单的)
			for (int j = 0; j < sf.length; j++) {
				if(sf[j]==0){
					if(ztandDj[j][0]>0){
						ztandDj[j][0]-=1;
					}
				}
			}
			//查看改变后的等级 修改优先级
			for (int j = 0; j < f.length; j++) {
				//未在优先级里的修改
				if(f[j][1]==0){
					if(f[j][0]>5){
						f[j][1]=1;
					}
				}else{//在优先级里的修改
					if(f[j][0]<4){
						f[j][1]=0;
					}
				}
			}
			//重置标记数组
			for (int j = 0; j < sf.length; j++) {
				sf[j]=0;
			}
			//打印每次变化的等级和优先级：
			/*System.out.println(i+"秒后：");
			for (int j = 0; j < f.length; j++) {
				System.out.println("第"+(j+1)+"个商家：等级："f[j][0]+" 是否优先级状态"+f[j][1]);
			}*/
		}
		int count = 0;
		//计数统计在优先级缓存中的商家
		for (int i = 0; i < f.length; i++) {
			if(f[i][1]==1){
				count++;
			}
		}
		System.out.println(count);
	}
}