2018字节跳动后端笔试第二批三个题

链接：https://www.nowcoder.com/questionTerminal/429c2c5a984540d5ab7b6fa6f0aaa8b5
来源：牛客网

作为一个手串艺人，有金主向你订购了一条包含n个杂色串珠的手串——每个串珠要么无色，要么涂了若干种颜色。为了使手串的色彩看起来不那么单调，金主要求，手串上的任意一种颜色（不包含无色），在任意连续的m个串珠里至多出现一次（注意这里手串是一个环形）。手串上的颜色一共有c种。现在按顺时针序告诉你n个串珠的手串上，每个串珠用所包含的颜色分别有哪些。请你判断该手串上有多少种颜色不符合要求。即询问有多少种颜色在任意连续m个串珠中出现了至少两次。

输入描述:

第一行输入n，m，c三个数，用空格隔开。(1 <= n <= 10000, 1 <= m <= 1000, 1 <= c <= 50) 接下来n行每行的第一个数num_i(0 <= num_i <= c)表示第i颗珠子有多少种颜色。接下来依次读入num_i个数字，每个数字x表示第i颗柱子上包含第x种颜色(1 <= x <= c)

输出描述:

一个非负整数，表示该手链上有多少种颜色不符需求。
示例1
输入

5 2 3
3 1 2 3
0
2 2 3
1 2
1 3
输出

2
说明

第一种颜色出现在第1颗串珠，与规则无冲突。
第二种颜色分别出现在第 1，3，4颗串珠，第3颗与第4颗串珠相邻，所以不合要求。
第三种颜色分别出现在第1，3，5颗串珠，第5颗串珠的下一个是第1颗，所以不合要求。
总计有2种颜色的分布是有问题的。
这里第2颗串珠是透明的。

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m =scan .nextInt();
        int c = scan.nextInt();
        Map<Integer, List<Integer>> map = new HashMap<>();
        for(int i = 0;i<n;++i){
            int a = scan.nextInt();
            for(int j = 0; j < a ; ++j){
                int b = scan.nextInt();
                 
                if(map.containsKey(b)){
                    map.get(b).add(i+1);
                }else{
                    List<Integer> list = new LinkedList<>();
                    list.add(i+1);
                    map.put(b, list);
                }
            }
        }
        int sum=0;
         
        for(int i = 0;i<c;++i ){
            List<Integer> list = map.get(i+1);
            for(int j = 0; j<list.size();++j){
                if(j<list.size()-1&&list.get(j+1)-list.get(j)<=m-1){
                     
                    ++sum;
                     
                    break;
                }
                if(j==list.size()-1){
                    if(n-list.get(list.size()-1)+list.get(0)<=m-1){
                        ++sum;
                         
                     
                    }
                }
            }
             
        }
         
        System.out.println(sum);
         
    }
}

链接：https://www.nowcoder.com/questionTerminal/66b68750cf63406ca1db25d4ad6febbf
来源：牛客网

为了不断优化推荐效果，今日头条每天要存储和处理海量数据。假设有这样一种场景：我们对用户按照它们的注册时间先后来标号，对于一类文章，每个用户都有不同的喜好值，我们会想知道某一段时间内注册的用户（标号相连的一批用户）中，有多少用户对这类文章喜好值为k。因为一些特殊的原因，不会出现一个查询的用户区间完全覆盖另一个查询的用户区间(不存在L1<=L2<=R2<=R1)。

输入描述:

输入： 第1行为n代表用户的个数 第2行为n个整数，第i个代表用户标号为i的用户对某类文章的喜好度 第3行为一个正整数q代表查询的组数 第4行到第（3+q）行，每行包含3个整数l,r,k代表一组查询，即标号为l<=i<=r的用户中对这类文章喜好值为k的用户的个数。 数据范围n <= 300000,q<=300000 k是整型

输出描述:

输出：一共q行，每行一个整数代表喜好值为k的用户的个数
示例1
输入

5
1 2 3 3 5
3
1 2 1
2 4 5
3 5 3
输出

1
0
2
说明

样例解释:
有5个用户，喜好值为分别为1、2、3、3、5，
第一组询问对于标号[1,2]的用户喜好值为1的用户的个数是1
第二组询问对于标号[2,4]的用户喜好值为5的用户的个数是0
第三组询问对于标号[3,5]的用户喜好值为3的用户的个数是2

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
 
public class Main {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int a = scan.nextInt();
            int[] number = new int[a];
            for(int i = 0; i<a;++i){
                number[i] = scan.nextInt();
            }
            Map<Integer, List<Integer>> map = new HashMap<>();
            for(int i = 0; i<number.length ; ++i){
                int c=number[i];
                 
                if(map.containsKey(c)){
                    map.get(c).add(i+1);
                }else{
                    List<Integer> list = new LinkedList<>();
                    list.add(i+1);
                    map.put(c, list);
                }
            }
             
            int b =scan.nextInt();
            int []g = new int[b];
            int sun = 0;
            for(int i = 0;i<b;++i){
                int q = scan.nextInt();
                int w = scan.nextInt();
                int e = scan.nextInt();
                if(map.containsKey(e)!=false){
                    List<Integer> list = map.get(e);
                    for(int j =0 ; j <list.size();++j){
                     
                        if(list.get(j)>=q&&list.get(j)<=w){
                            ++sun;
                        }
                    }
                    g[i]=sun;
                    sun = 0;
                }else{
                    g[i] =sun;
                }
            }
            for(int i = 0;i<b;++i){
                System.out.println(g[i]);
            }
        }
}

链接：https://www.nowcoder.com/questionTerminal/43488319efef4edabada3ca481068762
来源：牛客网

【编码题】字符串S由小写字母构成，长度为n。定义一种操作，每次都可以挑选字符串中任意的两个相邻字母进行交换。询问在至多交换m次之后，字符串中最多有多少个连续的位置上的字母相同？

输入描述:

第一行为一个字符串S与一个非负整数m。(1 <= |S| <= 1000, 1 <= m <= 1000000)

输出描述:

一个非负整数，表示操作之后，连续最长的相同字母数量。
示例1
输入

abcbaa 2
输出

2
说明

使2个字母a连续出现，至少需要3次操作。即把第1个位置上的a移动到第4个位置。
所以在至多操作2次的情况下，最多只能使2个b或2个a连续出现。

根据这个链接博客写的这个题

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main6 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String[]a= scan.nextLine().split(" ");
		
		char[]b=a[0].toCharArray();
		int c =Integer.parseInt(a[1]);
		int max =0;
		Map<Character,List<Integer>> map = new HashMap<Character, List<Integer>>();
		for(int i = 0; i<b.length ;++i){
            if(map.containsKey(b[i])){
                map.get(b[i]).add(i+1);
            }else{
                List <Integer> list = new LinkedList<Integer>();
                list.add(i+1);
                map.put(b[i], list);
            }
        }
		
		for(Character key: map.keySet()){
			List <Integer> list = map.get(key);
			for(int i = 0; i<list.size();++i){
				int ctr = list.get(i);
				//创建移动步数数组
				int move[] = new int[list.size()];
				for(int j = 0 ;j<list.size();++j){
					//往ctr靠拢的步数，为什么Math.abs(i-j)呢？
					//Math.abs(list.get(j)-ctr)是实际字符串你们相隔几步
					//Math.abs(j-i)在同一个字符数组相隔的距离，这时不要想里面的数，光想这个数组的下标
					move[j]=Math.abs(list.get(j)-ctr)-Math.abs(j-i);
					
				}
				//排序
				
				Arrays.sort(move);
				int sum = 0;
				for(int k = 0;k<move.length; k++){
					sum += move[k];
					if(sum>c){
						break;
					}
					if(k+1>max){
						max = k+1;
					}
				}
			}
			
		}
		
		System.out.println(max);
	}
}