关闭。这个问题需要细节或清晰。它目前不接受答案。
**想改进这个问题吗？**通过编辑这个帖子来添加细节并澄清问题。

两天前关门了。
改进这个问题
我试图解决一个问题，即有两个数组x[]和y[]。有一个操作同时在两个数组上进行遍历。我需要做的是从x[]中获取一个元素并将其放入一个列表中。然后从y[]中获取一个元素，并从列表中删除distinct元素。如果操作成功执行，例如列表中的不同元素数等于或大于，则yi.将操作计数增加1。删除要这样做的操作
删除不同的元素，如从最高频率计数到最低频率计数。
如果元素频率计数相同，则去除席数值较低的元素。
我正在用java解决这个问题。我的方法是使用链接的hashmap并将所有值放入其中。关键是席和值是频率计数。然后我使用了一个比较器，它将根据上述给定条件对hashmap进行排序。我遇到的问题是在使用迭代器时得到并发的modificationexception。虽然我不知道哪里是解决这个问题的正确方法，或者我应该用其他方法来解决它？例如：
x=[1,1,2,3]y=[3,2,3,2]
首先我们把1放入列表，然后我们取y0，也就是3。由于y0大于1，因此操作不成功。然后我们把1加到列表中，取y1，也就是2，最后一个列表有3个不同的元素，y3是2，所以从列表中去掉一个1，然后去掉2，因为2小于3。所以总的结果是1。代码如下

import java.util.*;

public class Count {

    public static void main(String[] args) {
        int[] A = {1,2,2,3,3};
        int[] B = {1,2,2,2,2};
        System.out.println(getResult(A,B));
    }

    private  static int getResult(int[] a, int[] b) {
        Map<Integer,Integer> sortedMap = new LinkedHashMap<>();
        int result = 0;
        for(int i=0;i<b.length;i++){
            addValues(a[i],sortedMap);
            int count = b[i];
            sortedMap = sortAndUpdate(sortedMap);
            if(getDistictCount(sortedMap)>=b[i]){
                System.out.println("current size of map:"+getDistictCount(sortedMap));
                for(Map.Entry<Integer,Integer> entry = (Map.Entry<Integer, Integer>) sortedMap.entrySet(); count>0;){
                    Integer key = entry.getKey();
                    int value = sortedMap.get(key);
                    value--;
                    if(value==0){
                       sortedMap.remove(key);
                    }else sortedMap.put(key,value);
                    count--;
                    sortedMap = sortAndUpdate(sortedMap);
                }
                result++;
            }

        }
        return result;
    }

    private static int getDistictCount( Map<Integer, Integer> hashMap) {
        return hashMap.keySet().size();
    }
    private static void addValues(int v, Map<Integer, Integer> hashMap) {

        if(hashMap.get(v)==null){
                hashMap.put(v,1);
            }else
            {   int count  = hashMap.get(v);
                hashMap.put(v,count++);
            }

    }

    private static Map<Integer, Integer> sortAndUpdate(Map<Integer,Integer> sortedMap){
        HashMap<Integer,Integer> hashMap = new HashMap<>(sortedMap);
        List<Map.Entry<Integer,Integer>> list = new ArrayList(hashMap.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                if(o1.getValue().compareTo(o2.getValue())==0){
                    return o1.getKey().compareTo(o2.getKey());
                }else
                    return o2.getValue().compareTo(o1.getValue());
            }
        });
        sortedMap.clear();
        for(Map.Entry<Integer, Integer> item: list){
            sortedMap.put(item.getKey(),item.getValue());
        }
        return sortedMap;
    }

}