如果生活突然向你发难

躲不过那就迎面而战

所谓无坚不摧

是能享受最好的，也能承受最坏的

大不了逢山开路，遇水搭桥

若你决定灿烂，山无遮，海无拦

A：特殊日期

问题描述

对于一个日期，我们可以计算出年份的各个数位上的数字之和，也可以分别计算月和日的各位数字之和。请问从 1900 年 1 月 1 日至 9999 年 12 月 31日，总共有多少天，年份的数位数字之和等于月的数位数字之和加日的数位数字之和。

例如，2022 年 11 月 13 日满足要求，因为 2+0+2+2=(1+1)+(1+3) 。

请提交满足条件的日期的总数量。

题解思路：通过 time包直接进行读取判断即可

参考代码：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDate date = LocalDate.of(1900,1,1);
        int count=0;
        while(true){
          if(date.getYear()==9999&&date.getMonth().getValue()==12&&date.getDayOfMonth()==31) break;
          int x1 = date.getYear()%10;
          int x2 = date.getYear()/10%10;
          int x3 = date.getYear()/100%10;
          int x4 = date.getYear()/1000;
          int y1 = date.getMonth().getValue()%10;
          int y2 = date.getMonth().getValue()/10;
          int y3 = date.getDayOfMonth()%10;
          int y4 = date.getDayOfMonth()/10;
          if((x1+x2+x3+x4)==(y1+y2+y3+y4)) count++;
          date = date.plusDays(1);
        }
        System.out.println(count);
    }
}

B：重合次数

问题描述

在同一天中, 从上午 6 点 13 分 22 秒到下午 14 点 36 分 20 秒, 钟表上的 分针和秒针一共重合了多少次?

注意时针、分针、秒针都围绕中心敳匀速运动。

 题解思路：

误区在于一个小时重合60次，实际上每个小时只会重合59次，从早上6点到14点总共8小时，59*8=472，然后从13分22秒到35分22秒多有22次重合，而35分22秒多到36分20秒没有重合，因此结果：59*8*22=494

答案：

494

C：左移右移

问题描述

小蓝有一个长度为 N 的数组, 初始时从左到右依次是 1,2,3,…N。

之后小蓝对这个数组进行了 M 次操作, 每次操作可能是以下 2 种之一:

1. 左移 x, 即把 x 移动到最左边。

2. 右移 x, 即把 x 移动到最右边。

请你回答经过 M 次操作之后, 数组从左到右每个数是多少?

输入格式

第一行包含 2 个整数, N 和 M 。

以下 M 行每行一个操作, 其中 “L x "表示左移 x,"R x "表示右移 x 。

输出格式

输出 N 个数, 代表操作后的数组。

样例输入

5 3
L 3
L 2
R 1

样例输出

2 3 4 5 1

样例说明

样例中的数组变化如下:

[1,2,3,4,5]→[3,1,2,4,5]→[2,3,1,4,5]→[2,3,4,5,1][1,2,3,4,5]→[3,1,2,4,5]→[2,3,1,4,5]→[2,3,4,5,1]

评测用例规模与约定

对于 50% 的评测用例, 1≤N,M≤10000

对于 100% 的评测用例, 1≤N,M≤200000,1≤x≤N

题解思路：

我们可以知道的结论：最后移动的数一定在两边，且不会因为前面移动过这个数而对这个数产生影响，而前面的数会因为后面的数移动而改变位置，那么我们是否可以逆向判断，固定 两边的数，其他没有移动过的数按照从左到右顺序排列

那我们需要用到哪些东西？

一个长M的数组，去存储移动信息

一个长N+1的boolean数组，去判断1--N是否移动使用

一个长为N的数组，去存储最终结果并用于输出

参考代码：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		char []s=new char[m];//存储输入的字符
		int []arr=new int[m];//存储输入的值
		boolean []bl=new boolean[n+1];//判断是否用于交换
		int []jg=new int[n];//存储结果
		for(int i=0;i<m;i++){//输入
		    s[i]=sc.next().charAt(0);
		    arr[i]=sc.nextInt();
		}
		int l=0,r=n-1;
		for(int i=m-1;i>=0;i--){//逆序去判断每一个数
		    if(s[i]=='L'&&bl[arr[i]]==false){//说明这个数在最左边且未被使用
		        jg[l]=arr[i];
		        bl[arr[i]]=true;
		        l++;//左端点+1，下一个移到最左边的话会在这个数的右边
		    }else if(s[i]=='R'&&bl[arr[i]]==false){//说明这个数在最右边且未被使用
		        jg[r]=arr[i];
		        bl[arr[i]]=true;
		        r--;//右端点-1，，下一个移到最右边的话会在这个数的左边
		    }
		}
		for(int i=1;i<=n;i++){//去判断所有数字中没有使用过的
		    if(bl[i]==false){//进行存储
		        jg[l]=i;
		        l++;
		    }
		}
		for(int i=0;i<n;i++) System.out.print(jg[i]+" ");//输出
	}
}

D：近似gcd

问题描述

小蓝有一个长度为 nn 的数组 A=(a1,a2,⋯ ,an), 数组的子数组被定义为从 原数组中选出连续的一个或多个元素组成的数组。数组的最大公约数指的是数 组中所有元素的最大公约数。如果最多更改数组中的一个元素之后, 数组的最 大公约数为 g, 那么称 g 为这个数组的近似 GCD。一个数组的近似 GCD 可能 有多种取值。

具体的, 判断 g 是否为一个子数组的近似 GCD 如下:

1. 如果这个子数组的最大公约数就是 g, 那么说明 g 是其近似 GCD。

2. 在修改这个子数组中的一个元素之后 (可以改成想要的任何值), 子数 组的最大公约数为 g, 那么说明 g 是这个子数组的近似 GCD。

小蓝想知道, 数组 A 有多少个长度大于等于 2 的子数组满足近似 GCD 的 值为 g 。

输入格式

输入的第一行包含两个整数 n,g, 用一个空格分隔, 分别表示数组 A 的长 度和 g 的值。

第二行包含 nn 个整数 a1,a2,⋯ ,an, 相邻两个整数之间用一个空格分隔。

输出格式

输出一行包含一个整数表示数组 A 有多少个长度大于等于 2 的子数组的近 似 GCD 的值为 g

样例输入

5 3
1 3 6 4 10

样例输出

5

样例说明

满足条件的子数组有 5 个:

[1,3][1,3] : 将 1 修改为 3 后, 这个子数组的最大公约数为 3 , 满足条件。

[1,3,6][1,3,6] : 将 1 修改为 3 后, 这个子数组的最大公约数为 3 , 满足条件。

[3,6]：这个子数组的最大公约数就是 3 , 满足条件。

[3,6,4][3,6,4] : 将 4 修改为 3 后, 这个子数组的最大公约数为 3 , 满足条件。

[6,4][6,4] : 将 4 修改为 3 后, 这个子数组的最大公约数为 3 , 满足条件。

评测用例规模与约定

对于 20%20% 的评测用例, 2≤n≤10^2 ；

对于 40%40% 的评测用例, 2≤n≤10^3;

对于所有评测用例, 2≤n≤10^5,1≤g,ai≤10^9。

题解思路：

对于每一个数，我们先去判断这个数是否为g的倍数，我们将非g倍数的数提取出来存放对应下标，在[L,R]区间中，按照2/3/4.....R-L个数的数组一共存在：(1+2+...+R-L-1)*(R-L-1)/2个

而在区间内最多只能存在一个数不是g的倍数

我们按照每一个提取的数为节点，进行与前后数的组合统计，得到公式如下：

((arr[r]-arr[r-2]-2)+(arr[r]-arr[r-1]-1))*(arr[r-1]-arr[r-2])/2

最终特判所有数都是g的倍数与只有一个数是g的倍数的情况即可

PS： 不知道怎么说比较清楚，通过等差公式推出来的，可以看代码试试

参考代码：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long n=sc.nextLong();
		int m=sc.nextInt();
		long []arr=new long[100010];
		int l=1;//输入和提取非m倍数的数
		for(long i=1;i<=n;i++){
		    int a=sc.nextInt();
		    if(a%m!=0){
		        arr[l]=i;
		        l++;
		    }
		}
        arr[l]=n+1;//最有端点设置一个
		long sum=0;
		for(int i=2;i<l;i++){//公式代入
		    sum+=((arr[i]-arr[i-2]-2)+(arr[i]-arr[i-1]-1))*(arr[i-1]-arr[i-2])/2;
		}
    if(l<=2){//只有一个非m倍数的数或者全是m倍数的数
      System.out.println(n*(n-1)/2);
      return;
    }
    //最右端点的特殊求和
    sum+=(arr[l]-arr[l-2]-1)*(arr[l]-arr[l-2]-2)/2;
		System.out.println(sum);
	}
}