Question

我们有字符串元素列表。例如[＆＃34; A＆＃34;，＆＃34; B＆＃34;，＆＃34; B＆＃34;，＆＃34; A＆＃34;，＆＃34; K＆＃34;，＆＃ 34; B＆＃34]。我们的计划必须在下一批[[＆＃34; A＆＃34;，＆＃34; B＆＃34;，＆＃34; K＆＃34;]，[＆＃34; B＆＃34;，＆＃34; A＆＃34;]，[＆＃34; B＆＃34;]]。所有的切口必须只包含唯一的元素，批次数必须最小，算法的复杂度必须是线性的O（n）。

Answer 1

尝试使用列表和设置。您的Set不允许重复值和List允许。因此，您可能希望迭代所有元素，同时添加set检查长度是否更改以及长度是否更改意味着它是重复的并将其添加到List。所以你的下一组将是列表。除非列表大小为零，否则继续保持相同。这只是暗示希望这会有所帮助。

快乐学习：）

Answer 2

这个应该有效。（已经过测试）

    ArrayList<ArrayList<String>> batches = new ArrayList<ArrayList<String>>();
    ArrayList<String> arr = new ArrayList<String>();

    arr.add("A");
    arr.add("B");
    arr.add("B");
    arr.add("A");
    arr.add("K");
    arr.add("B");
    arr.add("A");

    batches.add(new ArrayList<String>());

    int id = 0, arrID = 0;

    while(arrID < arr.size())
    {
        if(batches.get(id).contains(arr.get(arrID)))
        {
            id ++;
            if(id+1 > batches.size())
                batches.add(new ArrayList<String>());
        }
        else
        {
            batches.get(id).add(arr.get(arrID));
            arrID ++;
            id = 0;
        }
    }

    System.out.println("Results: ");
    for(int i=0; i<batches.size(); i++)
    {
        System.out.println("Batch "+i);
        for(int x=0; x<batches.get(i).size(); x++)
            System.out.println(batches.get(i).get(x));
    }

Answer 3

我可能会做一个列表清单

例如

包假人;

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

公共类BatchIt {

/**
 * @param args
 */
public static void main(String[] args) {
    List<List<String>> batches = new ArrayList<List<String>>();
    List<String> firstBatch = new ArrayList<String>();
    batches.add(firstBatch);
    for (String input : args) {
        boolean inputAdded = false;
        for (List<String> batch : batches) {
            if(!batch.contains(input)){
                batch.add(input);
                inputAdded = true;
                break;
            }
        }
        if(!inputAdded){
            List<String> nextBatch = new ArrayList<String>();
            nextBatch.add(input);
            batches.add(nextBatch);
        }
    }
    System.out.print(batches);
}

}

Answer 4

当问题看起来像家庭作业时，我通常不回答，我认为这是。但是......这是一个使用List，Set和Recursion的简单明了的解决方案。（如果您关心订单，请将HashSet替换为LinkedHashSet）

import java.util.*;

public class StringBatches {
    public static void main(String[] args) {
        String[] ss = {"A","B","B","A","K","B", "A"};

        List<Set<String>> l = new ArrayList<Set<String>>();
        for (String s : ss) {
            putInUniqueSet(l, 0, s);
        }
        System.out.println( l );
    }

    public static boolean putInUniqueSet( List<Set<String>> l, int idx, String s ) {
        if( l.size() <= idx )
            l.add(new HashSet<String>());
        return !l.get(idx).add(s) ? putInUniqueSet(l, idx+1, s) : true;
    }
}

<强>输出：

[[A, B, K], [A, B], [A, B]]

拆分唯一批次

4 个答案: