Question

我有一张如下图所示的地图：

Key        Value
    23      20
    32      20      (20+20  =40 , min=23 max=32)
    43      18
    45      24      (24+18 =42 , since 42 >40 so here min and max will be same that is 43
    47      10    
    56      6       (24 +10 +6 =40) so here min =45 and max = 56
    43       50    ****so how we will handle the case where value is greater  than            key 50 >43 ********

所以我已经实现了将采用

的逻辑

1）其中地图值的值达到40 2）计算时的地图值大于40

3） **没有实现第一个实例，其中初始级别的map值在第一个实例中更大的场景，如上图所示，键为43，值为50 * *

现在请告知如何处理第三种情况，我实施的是...... 创建一个Pair类，它将保存键和值。

class Pair {
    public int key;
    public int value;

    public Pair(int key, int value){
        this.key = key;
        this.value = value;
    }
}

母鸡创建一对配对列表并迭代它。如果总和为0，则初始化最小值和最大值。然后对于迭代的每一对，将其值添加到总和。如果总和较差，则继续循环并更新最大密钥，否则您有两种情况：

总和等于限制，因此请更新最大键
总和不等于限制（因此它更优），减少索引并且不更新最大键

public static void main(String[] arg) {
 Map<Long, Integer> m = new LinkedHashMap<>();
//fill your map here
List<Pair> l = new ArrayList<>();
for(Map.Entry<Long, Integer> entries : m.entrySet()){
    l.add(new Pair(entries.getKey(), entries.getValue()));
}

//Now you have a list of Pair
    int sum = 0;
    int min = -1;
    int max = -1;

    for(int i = 0; i < pairList.size(); i++){
        Pair p = pairList.get(i);
        if(sum == 0){
            min = p.key;
            max = p.key;
        }
        sum += p.value;
        if(sum < LIMIT){
            max = p.key;
        } else {
            if(sum > LIMIT){
                i--;
            } else {
                max = p.key;
            }
            System.out.println(min+"_"+max);
            sum = 0;
        }
    }
}

打印哪些：

23_32
43_43
45_56

请问如何处理第一种情况，即初始级别的地图值在初始时更大的第一种情况，如上图所示，键为43，值为50 * *

Answer 1

您仍然没有真正指定明确您要实现的目标。您没有说输入映射的键是否按升序排列（即，它是否是TreeMap）。在原始问题（在第一条评论中链接）中，您的输入是2个列表。您发布的示例根本没有任何意义，因为它包含key = 43 两次 - 因此它不能是地图。你的描述听起来像是键和值之间存在一些约束（值50大于键43），但这可能只是你解释的一个神器。

您的解决方案方法以及如何更新实施中的某些变量可能是尝试提供准确的信息。但也许对您的实际目标的口头或半正式描述在这里更有帮助。也许你只是不能解释你想要实现的目标。在最坏的情况下，你不知道它。

目前，我的解释大致如下：您的输入包含两个列表（！）。并且您正在尝试查找第一个列表的范围，以便第二个列表中相应值的总和至少为40.

如果是这种情况，您可以计算总和应该开始的值列表以及求和结束位置的索引。当您拥有这些索引时，您可以从第一个列表中获取相应的“键”。

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

public class SumSplit
{
    public static void main(String[] args)
    {
        List<Integer> keys = new ArrayList<Integer>();
        keys.add(23);
        keys.add(32);
        keys.add(43);
        keys.add(45);
        keys.add(47);
        keys.add(56);
        keys.add(43);

        List<Integer> values = new ArrayList<Integer>();
        values.add(20);
        values.add(20);
        values.add(18);
        values.add(24);
        values.add(10);
        values.add( 6);
        values.add(50);

        final int SPLIT_VALUE = 40;

        List<Integer> minIndices = new ArrayList<Integer>();
        List<Integer> maxIndices = new ArrayList<Integer>();

        int sum = 0;
        int minIndex = -1;
        for (int i=0; i<keys.size(); i++)
        {
            Integer value = values.get(i);
            sum += value;

            if (minIndex == -1)
            {
                minIndex = i;
            }
            if (sum >= SPLIT_VALUE)
            {
                minIndices.add(minIndex);
                maxIndices.add(i);
                minIndex = -1;
                sum = 0;
            }
        }


        for (int i=0; i<minIndices.size(); i++)
        {
            Integer min = minIndices.get(i);
            Integer max = maxIndices.get(i);
            System.out.println("min: "+keys.get(min)+", max "+keys.get(max));
            printInfo(min, max, keys, values);
        }
    }

    private static void printInfo(int min, int max, List<Integer> keys, List<Integer> values)
    {
        int sum = 0;
        for (int i=min; i<=max; i++)
        {
            Integer key = keys.get(i);
            Integer value = values.get(i);
            sum += value;
            System.out.println("    "+key+" : "+value+"   (sum until now: "+sum+")");
        }
        System.out.println("Sum: "+sum);
    }
}

如果这不是您要实现的目标，请明确描述您的实际目标。

在特定条件下从列表中提取数据

1 个答案: