2020年智算之道初赛第一场题解

一、排队

小 A 现在站在一个 n 个人的队伍里排队，他们的编号依次为 1∼n，现在她面前有 m 个窗口，其中第 i 个窗口会给出一个数字 ai​，然后将队伍中所有编号为 ai​ 倍数的人带出队伍，请问最后队伍中还剩下多少个人？

输入格式

第一行两个用空格隔开的整数分别表示 n,m

第二行 m 个用空格隔开的整数，其中第 i个代表 ai​

输出格式

输出一个整数，代表剩下多少个人

数据规模与约定

对于 30% 的数据，1≤n≤100,1≤m≤10

对于60% 的数据，1≤n≤1000,1≤m≤10

对于 100%的数据，1≤n≤100000,1≤m≤100,1≤ai​≤n

样例输入

10 3
3 4 5

样例输出

3

当时自己的代码（未满分）

//这是自己得了20分的代码，希望有大佬帮忙解决一下得满分


import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int n,m;
		n=in.nextInt();
		m=in.nextInt();
		int[] temp=new int[m];
		for(int i=0;i<m;i++) {
			temp[i]=in.nextInt();
		}
		System.out.println(pan(n,temp));
	}
	private static int pan(int n,int a[]) {
		int num=0,all=n;
		Arrays.sort(a);
		
		for(int i=0;i<a.length;i++) {
			num=all-n/a[i];
			all=all-n/a[i];
		}
		return num;
		
	}
}

官方题解

题目给定一个 1 ∼ n 的序列和 m 个数，然后将每个数的所有倍数从队伍中带走。根据题意

我们可以知道，只有 i 不是这 m 个数的倍数时，它才会最终留在队伍中，所以对于 i ，我们

只需要处理出它是否是任何一个数的倍数即可。

二、开关

小 B 面前有 n个开关，开始时第 i 个开关的状态是 ai​，其中 ai​=1 表示第 i 个开关是开的，ai​=0 表示第 i个开关是关的。现在 小 B 获得了一种魔法，他可以进行若干次操作，每次操作可以选择一个数 x，然后把 x 号开关及其之前的所有开关状态反转（开变关，关变开），请问小 B 最少需要多少次操作才能使所有开关都变为关的状态。

输入格式

第一行一个整数表示 n

第二行为一个长度为 n 的 01 字符串，即每一位只会是 0 或者 1

输出格式

输出一个整数，表示最少需要多少次操作才能使所有开关都变为关的状态

数据规模与约定

对于 30% 的数据，1≤n≤20

对于60% 的数据，1≤n≤2000

对于 100% 的数据，1≤n≤200000

样例输入

4
1001

样例输出

3

当时自己的代码（满分但耗时较长）

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int n;
		String str;
		n=in.nextInt();
		str=in.next();
		System.out.println(pan(n,str));
	}
	private static int pan(int n,String str) {
		int len=str.length();
		int num=0;
		for(int i=0;i<len;i++) {
			if(i==0&&str.charAt(i)=='1') {
				do {
					i++;
				}
				while(i<len&&str.charAt(i)=='1');
				i--;
				num++;
			}
			else if(str.charAt(i)=='1') {
				do {
					i++;
				}
				while(i<len&&str.charAt(i)=='1');
				i--;
				num=num+2;
			}
		}
		return num;
		
	}
}

官方题解

题目的意思是初始给定一个 01 序列，问最少需要多少次操作，也就是将 1 ∼ i 的所有状态

都翻转，可以将整个序列都变成 0 。首先我们可以观察得到一个性质是如果对同一个位置操

作两遍魔法也就等同于没有操作，所以任意一个位置最多只有可能被操作一次。

对于 30% 的数据，因为 n 的范围只有 20 ，所以我们可以 dfs 枚举对每一位是否使用魔法，

检验是否将整个序列都变成 0 ，然后对答案进行更新。

对于 100% 的数据，我们考虑从序列头向序列尾贪心地进行处理，我们观察可以发现，如果

第 i 位是 1 且第 i − 1 位是 0 ，此时如果前 i − 1 位都已经为 0 ，我们可以通过对 i 操作一

次，对 i − 1 位使用一次魔法，从而将前 i 位都变成 0 。唯一需要注意的特例是第 1 位是否

为 1 ，它只需要一次翻转，特判一下即可。

三、字符串

给定两个字符串 S和 T，它们都只由小写字母组成。现在请计算出字符串 S 的本质不同的排列中有多少种是字符串 T 的子串。

本质不同，就是看起来不同，例如 aab 有 33 种本质不同的排列 aab, aba, baa。

输入格式

第一行有一个字符串 S

第二行有一个字符串 T

输出格式

输出一个整数表示字符串 S 的本质不同的排列中有多少种是字符串 T 的子串

数据规模与约定

对于 30% 的数据，1≤∣S∣≤5,1≤∣T∣≤200

对于 60% 的数据，1≤∣S∣≤2000,1≤∣T∣≤2000

对于 100% 的数据，1≤∣S∣≤200000,1≤∣T∣≤200000

样例输入

aab
abacabaa

样例输出

2

当时自己的代码（未满分）

//自己的代码，只得了30分，希望有大佬帮忙
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
	public static int t;//组合个数
	static ArrayList<String> al=new ArrayList<>();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		String S,T;
		S=in.next();
		T=in.next();
		System.out.println(pan(S,T));
		
	}
	private static int pan(String s,String t) {
		int num=0;
		fullPermutation(s);
        for (String str : al) {  
        	String temp=t.replaceAll(str, "");
        	if(!temp.equals(t)) {
    			num++;
    		}
      }  
		return num;
		
	}
	private static void fullPermutation(String s) {
		permutation(s.toCharArray(),0,s.length()-1);
		
	}
	private static void permutation(char[] c, int start, int end) {
		
		if(start==end)
			al.add(new String(c));
		
		else {
			for(int i=start;i<=end;i++) {
				if(i!=start && c[i]!=c[start] || i==start) {  //防止重复 
					swap(c,i,start); 
					permutation(c,start+1,end);    //继续深度搜索
					swap(c,i,start);	
				}	
			}	
		}
		
	}
 
	private static void swap(char[] c, int i, int start) {
		char temp=c[i];
		c[i]=c[start];
		c[start]=temp;
		
	}
}

官方题解

题目给定两个字符串 S 和 T ，问字符串 S 的本质不同的排列中有多少种是 T 的子串。

对于 30% 的数据，因为 S 的长度很小，我们可以将 S 的所有排列存储下来并判断是否出现

在 T 中暴力计算即可。

对于 60% 的数据，我们观察可以发现，如果字符串 S 和 T 的子串 X 有着相同的字母构

成，那么一定存在 S 的排列与 X 相同，在此基础上，我们只要判断当前的 X 在之前是否被

计算过了即可，这个判重过程可以在通过将字符串存在 map 中实现。

对于 100% 的数据，在 60% 的数据的基础上，我们将字符串 map 更换成哈希即可。