手串

/*判断手串珠子颜色不合格*/
    var line1 = readline().split(' ');
    var n = line1[0],
        m = line1[1],
        c = line1[2];
    var  obj = {};
    var arr = [];
    var cnt = 0;
    for(var i=0;i<n;i++){
        arr[i] = readline().split(' ');
        for(var j=1;j<=arr[i][0];j++){
            if(obj[arr[i][j]]){
                obj[arr[i][j]].push(i+1);
            }else{
                obj[arr[i][j]] = [i+1];
            }
        }
    }
    var temp = Object.values(obj);
    for(var i=0;i<temp.length;i++){
        for(var j=0;j<temp[i].length-1;j++){
            if((temp[i][j+1] - temp[i][j]) < m){
                cnt++;
                break;
            }
        }
        if(n-temp[i][temp.length-1]+temp[i][0] < m){
            cnt++;
            break;
        }
    }
    print(cnt);

#include <bits/stdc++.h>

using namespace std;

vector<int> a[20010];
int vis[60];
int main()
{
    int n,m,c;
    cin>>n>>m>>c;
    for(int i = 1; i <= n; i++)
    {
        int t;
        cin>>t;
        for(int j = 0; j < t; j++)
        {
            int x;cin>>x;
            a[i].push_back(x);
        }
    }
    int tot = 1;
    for(int i = n + 1;i <= n + m; i++) a[i] = a[tot++];

    map<int,int> color;
    int out = 1;
    for(int i = 1; i <= m; i++)
    {
        for(int j = 0; j < a[i].size(); j++)
        {
            color[a[i][j]]++;
        }
    }
    int ans = 0;
    for(int i = m + 1; i <= n + m + 1; i++)
    {
        map<int,int>::iterator it;
        for(it = color.begin(); it != color.end(); ++it)
        {
            int fi = it->first;
            int se = it->second;
            if(se >= 2)
            {
                if(!vis[fi]) ans++;
                vis[fi] = 1;
            }
        }
        for(int j = 0; j < a[out].size(); j++) color[a[out][j]]--;
        out++;
        for(int j = 0; j < a[i].size(); j++) color[a[i][j]]++;
        //printf("%d\n",ans);
    }
    cout<<ans<<endl;
    return 0;
}

// 初始化串珠总个数，连续的串珠个数，颜色种类数，所有串珠的颜色信息数组, 同一颜色的串珠数组, 不合格的颜色个数
let ballNums, linkNums, colorNums, ballColor = [], sameColorBall = [], count = 0;
[ballNums, linkNums, colorNums] = readline().split(' ').map(item => Number(item));
 
// 依次保存每个串珠所用颜色信息
// 数组的每个元素都是一个数组，元素数组的第一位代表颜色个数，后续代表所用颜色
for(let i = 0; i < ballNums; ++i) {
    ballColor[i] = readline().split(' ').map(item => Number(item))
}
 
// 将同一颜色出现的串珠序号进行收集
ballColor.forEach((item, index) => {
    // 若该串珠所用颜色种类大于0
    // console.log(item, 'item');
    if(item[0] > 0) {
        let colorArr = item.slice(1)
        // 下面的item代表不同的颜色种类
        colorArr.forEach(color => {
            // 如果之前已经保存过使用某颜色的串珠序号，则直接将其添加到数组中去
            if(sameColorBall[color]) {
                sameColorBall[color].push(index + 1)
            } else {
               sameColorBall[color] = [index + 1]
            }
        })
    }
    
})
sameColorBall.forEach(item => {
    // sameColorBall[0]代表使用‘0’这种颜色的所有串珠的序号数组,这里的序号是按顺序排列的
    for(let i = 0; i < item.length - 1; ++i) {
        if(item[i+1] - item[i] < linkNums) {
            ++count;
            break;
        }
        if(ballNums - item[item.length - 1] + item[0] < linkNums) {
            ++count;
            break;
        }
    }
})

console.log(count);

#include <stdio.h>
#include <malloc.h>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
 
int main()
{
    int n,m,c,numi,tmp,count=0;
    vector<int> color[50];
    scanf("%d %d %d", &n, &m, &c);
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &numi);
        for(int j = 0; j < numi; j++)
        {
            scanf("%d", &tmp);
            color[tmp-1].push_back(i);
        }
    }
    for(int i = 0; i < c; i++)
    {
        if(color[i].size() == 0)
            continue;
        sort(color[i].begin(), color[i].end());
        for(int j = 0; j < color[i].size()-1; j++)
        {
            if(color[i][j + 1] - color[i][j] < m || color[i][j] + n - color[i][j + 1] < m)
            {
                count++;
                break;
            }
        }
    }
    printf("%d\n", count);
    return 0;
}

/**
 * 构建hashmap，颜色作为key，所有拥有改颜色的珠子的位置列表作为value
 * 这么做的目的是分离颜色和位置，否则搞在一起很麻烦，最后返回不符合要求的颜色个数就可以了
 * 对于hashmap的各个value们，也就是拥有同样颜色的珠子的位置列表，我们这么处理
 * 首先用后一个位置的值前去前一个位置的值，如果差值小于m，就说明这个两个同色珠子挨得比较近，这个颜色不符合要求，直接break
 * 如果遍历完这个列表，还没有找出相邻的两个值之差小于m，我们就去看看最后一个和第一个值的差
 * 由于手串是环形的，所以第一个位置的值需要加上手串长度n，然后再减去列表中最后一个值，看看差值是否小于m
 * 列表中的相邻位置具有特殊意义，除了表示相同颜色珠子在原始手串中的位置，而且，任何相邻两个之差表示它们在原始手串之中的距离
 * 考虑到手串是个环，可能需要把第一个值加上手串长度减去最后一个值，首尾相接
 * 如果不用上述思路，每一次都遍历一遍m相当耗时，这个方法就是通过过程中相邻位置判断距离之差和m的关系，快速判断是否符合要求
 */

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();
        int c = sc.nextInt();
        HashMap<Integer, List<Integer>> colors_list = new HashMap<>();
        // 外层循环表示每一行输入，也就是每一个珠子的着色情况
        for (int i = 0; i < n; i++) {
            int colors = sc.nextInt();
            // 无色的就不讨论了
            if (colors != 0) {
                // 内层循环对每一颗珠子的颜色进行处理
                for (int j = 0; j < colors; j++) {
                    int color = sc.nextInt();
                    // 如果hashmap里面没有以color为键的，
                    if (! colors_list.containsKey(color)) {
                        List<Integer> color_list = new ArrayList<>();
                        colors_list.put(color, color_list);
                    }
                    // 相同颜色的珠子位置放进一个列表中，我这里习惯从1开始编号
                    colors_list.get(color).add(i+1);

                }
            }
        }
        // 用户编号我们从1开始,难点在于环形数组的处理
        int count = 0;
        for (List<Integer> perlist : colors_list.values()) {
            int size = perlist.size();
            if (size > 1) {
                // circled表示是否需要首尾相接判断一次，如果在遍历过程中发现有两颗之间的距离小于m，就直接break了，不会进行
                // 首尾判断。如果从左到右遍历完列表，还是没有发现距离小于m的，那就首位相接判断一下
                boolean circled = false;
                for (int i = 0; i < size -1; i++) {

                    if (perlist.get(i+1) - perlist.get(i) < m) {
                        circled = true;
                        count ++;
                        break;
                    }

                }
                if (!circled) {
                    if (perlist.get(0) + n - perlist.get(size-1) < m) {
                        count ++;
                    }
                }
            }
        }
        System.out.println(count);

    }
}

nmc=[int(i) for i in input().split()]
n=nmc[0]
m=nmc[1]
c=nmc[2]
ring=[]
count=0
for i in range(n):
    data=[int(k) for k in input().split()]
    N=data[0]
    if N>0:
        ring.append(data[1::])
    else:
        ring.append([])
for i in range(n):
    j=(i+1)%n
    for k in ring[i]:
        if k in ring[j]:
            count+=1
print(count)

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    int findDuplicate() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();   //n个珠子
        int m = sc.nextInt();   //每m个珠子不得重复颜色
        int c = sc.nextInt();   //共c种颜色
        int k = 0;              //第k颗串珠
        int wrongNum = 0;       //分布有问题的颜色数量
        List<List<Integer>> colorList = new ArrayList<>(c);
        for (int i = 0; i < c; i++) {
            colorList.add(new ArrayList<>());
        }
        //每个串珠分别存进颜色数组
        for (int i = 0; i < n; i++) {
            k++;
            sc.nextLine();
            int colorNum = sc.nextInt();
            for (int j = 0; j < colorNum; j++) {
                colorList.get(sc.nextInt() - 1).add(k);
            }

        }
        //判断每个颜色是否有问题
        for (int i = 0; i < c; i++) {
            List<Integer> thisList = colorList.get(i);
            for (int j = 0; j < thisList.size(); j++) {
                //如果连续两个之间的间隔小于m，则错误颜色数目+1.且该颜色判断完毕break
                if (j < thisList.size() - 1 && thisList.get(j + 1) - thisList.get(j) < m) {
                    wrongNum++;
                    break;
                }
                //判断最后一个和第一个之间的间隔
                if (j == thisList.size() - 1 && (thisList.get(j) + thisList.get(0)) % n < m) {
                    wrongNum++;
                }
            }
        }
        sc.close();
        return wrongNum;
    }

    public static void main(String[] args) {
        int wrongNum = new Main().findDuplicate();
        System.out.println(wrongNum);
    }
}

let [n,m,c] = readline().split(' '),
    arr = [];
for(let i=0;i<n;i++){
    arr.push(readline().split(' '))
}
//1、以颜色为索引，分好每个颜色所在的珠子。题目说不包含无色，就>0
let arrC = [];
for(let i=0;i<=c;i++){
    arrC[i] = []
}
for (let i = 0; i < arr.length; i++) {
    if(arr[i][0] > 0){
        for (let j = 1; j <= arr[i][0]; j++) {
            if(arrC[ arr[i][j] ]){
                arrC[ arr[i][j] ].push( i+1 )
            }else{
                arrC[arr[i][j]] = [ index+1 ]
            }
            
        }
    }
}
//2、判断相邻
let count = 0;
for(let i=1;i<arrC.length;i++){
    let len = arrC[i].length;
    for(let j = 0; j<len-1;j++){
        if( (arrC[i][j+1] - arrC[i][j]) < m){
            count++
            break
        }
        if(arrC[i][0] == 1 && arrC[i][len-1] == n){
            count ++
            break
        }
    }
}
print(count)

遍历查询