打卡第三天——14th蓝桥杯（今天很菜）

[归辞_备赛版]

第一题 门牌子制作

暴力出结果，统计字符串中2的个数

package month_training;

public class 门牌号 {
	static int n = 2020;
	public static void main(String[] args) {
		int count = 0;
		for(int i=1;i<=2020;i++) {
			String s = String.valueOf(i);
			int len = s.length();
			for(int j = 0;j<len;j++) {
				if(s.charAt(j)=='2') {
					count ++;
				}
			}
		}
		System.out.print(count);
	}

}

第二题 货物摆放

求因子，然后暴力

package month_training;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;

public class 货物摆放 {
	public static void main(String[] args) {
		ArrayList<Long> list = new ArrayList<>();
		long n = 2021041820210418L ;
		for(int i=1;i<=n/i;i++) {
			if(n%i==0) {
				if(!list.contains(i)) {
					list.add((long) i);
				}
				if(!list.contains(n/i)) {
					list.add(n/i);
				}
			}
		}
		int out = 0;
		int len = list.size();
		System.out.println(len);
		for(int i=0;i<len;i++) {
			for(int j = 0;j<len;j++) {
				for(int k =0;k<len;k++) {
					if(list.get(k)*list.get(j)*list.get(i)==n) {
						out++;
					}
				}
			}
		}
		System.out.println(out);
	}

}

第三题 跳跃

这题今天折磨我很久，一开始想用贪心，就求九个坐标里面最大的，每次都挑最大的走

然后又想试试DFS，然后又想试试BFS.....还想试试动态规划。笑死，然后一个也没做出来

人麻了，菜是原罪，等会去恶补之前的知识......诶

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class 跳跃_贪心 {
	static int[] dx = new int[]{0,0,0,-1,-1,-1,-2,-2,-3};
	static int[] dy = new int[]{-1,-2,-3,0,-1,-2,0,-1,0};
	

	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int[][] g = new int[10][10];
		int[][] w = new int[10][10];
		boolean[][] vt = new boolean[n][m];
		 for (int i = 0; i < n; i++) {
		        for (int j = 0; j < m; j++) {
		            g[i][j] = sc.nextInt();
		        }
		 }
		 for(int i=0;i<=n;i++) {
			 Arrays.fill(w[i], -(int)1e9);
		 }
		w[0][0] = g[0][0];
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				for(int k=0;k<9;k++) {
					int nx= i+dx[k] ;int ny = j +dy[k];
					if(nx>=0 && ny>=0) {
						w[i][j] = Math.max(w[i][j], w[nx][ny] + g[i][j]);
					}
				}
			}
		}
		System.out.println(w[n-1][m-1]);
		
	}
}

第四题

第四题的贪心思路很简单，但是我很菜，就是想不起来差分

我想怎么做呢？ 哎，我会存图，你每次询问我就for循环存图，对应的值加加。

然后呢， 我还会用链表把所有键收集起来，我还会数组排序.......

哦，最重要的，我还会优先队列，了不起的是还会根据存的图的值来重排序。

然后优先队列每弹出一个，我就用数组中最大的乘它。

结果就是，一边超时，一边还有答案错误，样例就过了四个，懒得改了，今天很心累，需要仔细复习基础知识

import java.io.*;
import java.util.*;


public class 重新排序 {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	static Map<Integer,Integer> map=new HashMap();
	public static void main(String[] args)throws IOException{
		String[] s = br.readLine().split(" "); 
		int n = Integer.parseInt(s[0]);
		int[] ori = new int[n];
		int[] qzh = new int[n+1];
		s = br.readLine().split(" "); 
		for(int i = 0 ;i<n;i++) {
			ori[i] = Integer.parseInt(s[i]);	
			qzh[i+1] = qzh[i] + ori[i];
		}
			
		s = br.readLine().split(" ");
		int m = Integer.parseInt(s[0]);
		int x=0,y=0;
		int sum = 0;
		for(int i = 0 ;i<m;i++) {
			s = br.readLine().split(" ");
			x = Integer.parseInt(s[0]);
			y = Integer.parseInt(s[1]);
			sum += qzh[y] - qzh[x-1];
			for(int j=x;j<=y;j++) {
				add(ori[j-1]);
			}
		}
		Arrays.sort(ori);
		List<Integer> nlist = new ArrayList<>(map.keySet());
		PriorityQueue<Integer> q2 = new PriorityQueue<>(new Comparator<Integer>() {
			public int compare(Integer o1,Integer o2) {
				if(map.get(o1)>map.get(o2))return -1;
				else return 1;
			}});
		for(Integer integer:nlist) {
			q2.add(integer);
		}
		int nsum = 0;
		int count = n-1;
		while(!q2.isEmpty()) {
			
			nsum += ori[count]*(map.get(q2.poll()));
			count--;
		}
		System.out.println(nsum-sum);
		
		
	}
	static void add(int a) {
		if(!map.containsKey(a)) {
			map.put(a, 1);
			return;
		}
		map.put(a, map.get(a)+1);
	}

}