一
为了不断优化推荐效果，今日头条每天要存储和处理海量数据。假设有这样一种场景：我们对用户按照它们的注册时间先后来标号，对于一类文章，每个用户都有不同的喜好值，我们会想知道某一段时间内注册的用户（标号相连的一批用户）中，有多少用户对这类文章喜好值为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:
1
0
2
例子说明1:
样例解释:
有5个用户，喜好值为分别为1、2、3、3、5，
第一组询问对于标号[1,2]的用户喜好值为1的用户的个数是1
第二组询问对于标号[2,4]的用户喜好值为5的用户的个数是0
第三组询问对于标号[3,5]的用户喜好值为3的用户的个数是2
流运算解决超时问题 java还是牛逼
如果其他语言可以使用二分查找法 要先进行排序 构建一个数据结构 进行排序
package com.luyi;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public ArrayList<Integer> list = new ArrayList<>();
public static void main(String[] args) {
Main main = new Main();
Scanner in = new Scanner(System.in);
int n = in.nextInt();
ArrayList<Integer> list;
Map<Integer, ArrayList<Integer>> map = new HashMap<>();
int[] users = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
int t = in.nextInt();
if (!map.containsKey(t)) {
list = new ArrayList<>();
list.add(i);
map.put(t, list);
} else {
list = map.get(t);
list.add(i);
map.put(t, list);
}
}
int m = in.nextInt();
int start;
int end;
int target;
for (int i = 0; i < m; ++i) {
start = in.nextInt();
end = in.nextInt();
target = in.nextInt();
main.search(start, end, target, map.get(target));
}
main.list.forEach(System.out::println);
}
public void search(int l, int r, int v, ArrayList<Integer> list) {
if (list != null) {
this.list.add(list.stream().filter(ss -> ss >= l && ss <= r).collect(Collectors.toList()).size());
} else {
this.list.add(0);
}
}
}
二
作为一个手串艺人，有金主向你订购了一条包含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
输出例子1:
2
例子说明1:
第一种颜色出现在第1颗串珠，与规则无冲突。
第二种颜色分别出现在第 1，3，4颗串珠，第3颗与第4颗串珠相邻，所以不合要求。
第三种颜色分别出现在第1，3，5颗串珠，第5颗串珠的下一个是第1颗，所以不合要求。
总计有2种颜色的分布是有问题的。
这里第2颗串珠是透明的。
挺简单的 18年和后两年的难度不是一个档次啊
import java.util.*;
public class Main {
public static void main (String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int c = in.nextInt();
Set<Integer> res = new HashSet<>();
int[] color = new int[c];
int count = 0;
for (int i = 0; i < n; i++) {
int colorNum = in.nextInt();
for (int j = 0; j < colorNum; j++) {
color[in.nextInt() - 1]++;
}
count++;
if (count == m) {
for (int j = 0; j < c; j++) {
if(color[j] >= 2) {
res.add(j);
}
}
count = 0;
color = new int[c];
}
}
for (int j = 0; j < c; j++) {
if(color[j] >= 2) {
res.add(j);
}
}
System.out.println(res.size());
}
}
三
【编码题】字符串S由小写字母构成，长度为n。定义一种操作，每次都可以挑选字符串中任意的两个相邻字母进行交换。询问在至多交换m次之后，字符串中最多有多少个连续的位置上的字母相同？
输入描述:
第一行为一个字符串S与一个非负整数m。(1 <= |S| <= 1000, 1 <= m <= 1000000)
输出描述:
一个非负整数，表示操作之后，连续最长的相同字母数量。
输入例子1:
abcbaa 2
输出例子1:
2
例子说明1:
使2个字母a连续出现，至少需要3次操作。即把第1个位置上的a移动到第4个位置。
所以在至多操作2次的情况下，最多只能使2个b或2个a连续出现。
package com.luyi;
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.next();
int m = in.nextInt();
char[] ch = str.toCharArray();
int n = ch.length;
ArrayList<Integer> list = new ArrayList<>();
Map<Character, ArrayList<Integer>> map = new HashMap<>();
// 将数据封装从 a -> 0, 5, 4
for(int i = 0; i < n; i++) {
if (map.containsKey(ch[i])) {
list = map.get(ch[i]);
list.add(i);
map.put(ch[i], list);
} else {
list = new ArrayList<>();
list.add(i);
map.put(ch[i], list);
}
}
// 测试用例 hkdbqojqvxlfulshrhpysezhlyzolb 20
// zoiumptccefmqdrjhhlgeyljbofwgvwogmvmpzgmoxdrbfdggimzifpfqmrqnrqrlobhluunzhyxrsicdhsrxpsrurqrewvrrcqc 200
int res = 0;
for(Map.Entry<Character, ArrayList<Integer>> entry: map.entrySet()) {
// a -> 0, 5, 4 让每一个数子作为中心 其他相同的字符往她身上靠
for (int i = 0; i < entry.getValue().size(); i++) {
ArrayList<Integer> moveList ;
int count = m;
boolean flag = true;
moveList = new ArrayList<>();
for (int j = 0; j < entry.getValue().size(); j++) {
if (!entry.getValue().get(j).equals(entry.getValue().get(i))) {
// Math.abs(i - j) 这里注意一下 的出来的是该字符是第几个靠过去的
// 因为当有字符靠过去之后 下一个字符只要一动到考过去的字符的旁边
moveList.add(Math.abs(entry.getValue().get(i) - entry.getValue().get(j)) - Math.abs(i - j));
}
}
int temp = 1;
// 排序一下 从最近的开始移动 贪心法
moveList.sort(Comparator.comparingInt( o -> o));
for (int j = 0; j < moveList.size(); j++) {
if(moveList.get(j) > count) {
flag = false;
break;
} else {
temp++;
count -= moveList.get(j);
}
}
if (flag && count >= 0) {
res = Math.max(res, moveList.size() + 1);
break;
} else {
res = Math.max(res, temp);
}
}
}
System.out.println(res);
}
}
三
题目描述
以下函数使用二分查找搜索一个增序的数组，当有多个元素值与目标元素相等时，返回最后一个元素的下标，目标元素不存在时返回-1。请指出程序代码中错误或不符最佳实践的地方（问题不止一处，请尽量找出所有你认为有问题的地方）
int BinarySearchMax(const std::vector<int>& data, int target)
{
int left = 0;
int right = data.size();
while (left < right) {
int mid = (left + right) / 2;
if (data[mid] <= target)
left = mid + 1;
else
right = mid - 1;
}
if (data[right] == target)
return right;
return -1;
}
链接：https://www.nowcoder.com/questionTerminal/5115b2f373944287a52ed9e2d839d54e
来源：牛客网
int BinarySearchMax(const std::vector<int>& data, int target)
{
int left = 0;
int right = data.size()-1;
while (left < right) {
int mid = (left + right) / 2;
if (data[mid] <= target)
left = mid;
else
right = mid - 1;
}
if (data[left] == target)
return left;
return -1;
449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
