请教一个集合的算法！

[杨哥儿]

即有集合A{01-18，10-18}；
集合B1{01-06},B2{07-08,10-12},B3{14-18}；
集合C1{01-11},C2{12-18}。
如何验证B1,B2,B3交集为空，C1,C2的交集为空。
如何验证B1,B2,B3的并集=集合A，实际不相等。
如何验证C1,C2的并集=集合A，实际不相等。
可以理解为集合A为工程施工日期，集合B为工程施工人员，集合C为工程施工地点。
要求该工程在每天的施工人员和地点安排有且必须唯一。
上面集合B和集合C安排有问题。
集合B缺少13，集合C多出9。
请问怎么用算法求出来？
谢谢！！
分不够明天加！

[Inhibitory]

这些都是简单的集合算法
1. 先对集合排序
2. 在数据结构的前几章里就讲了有序数组的合并等

[杨哥儿]

问题是库中"01-18，10-18”是字符格式的,是一个字符串，怎么解决？

[Inhibitory]

1. 表示集合的字符串分离成数组：String[] elems = "01-18, 10-18".split("\\s+,\\s+");
2. 字符串的比较大小: 实现一个Comparator接口，对字符串排序

[杨哥儿]

那如何判断"09”不在"01-08,10-18"中？

[Inhibitory]

这是一个字符串数组排序的例子

import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        // 把字符串分解成数组，以逗号(前后可以有空格)分离
        String[] ss = "01-06, 14-18, 10-12, 07-08".trim().split("\\s*,\\s*");

        // 对分解后的数组进行按从小到大排序
        Arrays.sort(ss, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                for (int i = 0; i < s1.length() && i < s2.length(); ++i) {
                    if (s1.charAt(i) != s2.charAt(i)) { return s1.charAt(i) - s2.charAt(i); }
                }

                if (s1.length() > s2.length()) {
                    return 1;
                } else if (s1.length() < s2.length()) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(ss));
    }
}

排序结果:
[01-06, 07-08, 10-12, 14-18]

[杨哥儿]

谢谢！我的字符串是已经排好序的。我只是想知道，怎样判断09不在“01-08，10-18”中？

[Inhibitory]

[Quote=引用 6 楼 uself 的回复:]

谢谢！我的字符串是已经排好序的。我只是想知道，怎样判断09不在“01-08，10-18”中？
[/Quote]
09本来就比08大，比10小啊，没看出问题

[qybao]

for example
String n = "9";
int vn = Integer.valueOf(n).intValue();
String b2 = "07-08,10-12";
String[] ss = b2.split(",");
for (String s : ss) {
String[] v = s.split("-");
if (v.length == 2) {
int v1 = Integer.valueOf(v[0]).intValue();
int v2 = Integer.valueOf(v[1]).intValue();
return (vn<=Math.max(v1, v2) && vn>=Math.min(v1, v2));
}
}
return false;

[杨哥儿]

我明白阿宝的意思！
先算出各段地起点和终点，该点与各起点和终点分别进行比较！
有没有更简单的算法？
第二个问题：
集合A={01-08,10-18}；
集合B={01-06,07-08,10-12,14-18}；
如何判断A=B？
事实不等，B多了个09。

[杨哥儿]

集合C={01-11,12-18}。这个多9。我打错了。对不起。

[yaoweijq]

第一感觉用线段树可以秒杀

[杨哥儿]

那请楼上给个思路 。大谢！

[nxd395239299]

    /**
     * 判断a是否在集合之中
      * 
     * @param string {"01-08","10-18"}
     * @param a 8
     * @return
     */
    public static boolean isHave(String[] string,int a)
    {
        boolean b = false;
        /** 遍历数组中的集合字符串 */
        for(int i =0;i < string.length;i++)
        {
            /** 拆分字符串为长度为2的数组 */
            String[] str = string[i].split("-");
            /** 长度不为2返回false */
            if(str.length != 2)
                return false;
            /** 如果在集合内就返回true */
            if(a >= Integer.valueOf(str[0]) && a <= Integer.valueOf(str[1]))
            {
                b = true;
                break;
            }
        }
        
        return b;
    }

[nxd395239299]

[Quote=引用 6 楼 uself 的回复:]
谢谢！我的字符串是已经排好序的。我只是想知道，怎样判断09不在“01-08，10-18”中？
[/Quote]

/**
     * 判断a是否在集合之中
      * 
     * @param string {"01-08","10-18"}
     * @param a 8
     * @return
     */
    public static boolean isHave(String[] string,int a)
    {
        boolean b = false;
        /** 遍历数组中的集合字符串 */
        for(int i =0;i < string.length;i++)
        {
            /** 拆分字符串为长度为2的数组 */
            String[] str = string[i].split("-");
            /** 长度不为2返回false */
            if(str.length != 2)
                return false;
            /** 如果在集合内就返回true */
            if(a >= Integer.valueOf(str[0]) && a <= Integer.valueOf(str[1]))
            {
                b = true;
                break;
            }
        }
        
        return b;
    }

[杨哥儿]

第一个问题大家思路是一样的。
但第二个问题：
集合A={01-08,10-18}；
集合B={01-06,07-08,10-12,14-18}；
如何判断A=B？

[flesu]

我是马甲：
1、集合A按“，”分组，得“01-08”和“10-18”等等；
2、每组按起止写入一个32位整形值的位中，用与运算或位运算才叫可，
得二进制值：11111111011111111100000000000000
3、集合B也用同样方法得到一个32位整形值。
4、两个值异或运算得到两个集合之间的不同。

[qybao]

改成集合来操作吧

String sa = "01-08,10-18";
String sb = "01-06,07-08,10-12,14-18";
Set<Integer> aSet = new HashSet<Integer>();
Set<Integer> bSet = new HashSet<Integer>();
String[] aa = sa.split(",");
for (String a : aa) {
    String[] va = a.split("-");
    if (va.length == 2) {
        int v1 = Integer.valueOf(va[0]).intValue();
        int v2 = Integer.valueOf(va[1]).intValue();
        for (int i=v1; i<=v2; i++) {
            aSet.add(Integer.valueOf(i));
        }
    }
}
String[] bb = sb.split(",");
for (String b : bb) {
    String[] vb = b.split("-");
    if (vb.length == 2) {
        int v1 = Integer.valueOf(vb[0]).intValue();
        int v2 = Integer.valueOf(vb[1]).intValue();
        for (int i=v1; i<=v2; i++) {
            bSet.add(Integer.valueOf(i));
        }
    }
}
//判断9是否在某个集合里
if (aSet.contails(Integer.valueOf("09"))) {
    System.out.println("contains");
}
//判断AB是否一样
if (aSet.containsAll(bSet)) { //集合A包含集合B的前提下判断
    //如果想准去判断，就用两个集合相减
    Set<Integer> subSet = new HashSet<Integer>(aSet);
    subSet.removeAll(bSet); 
    System.out.println(Arrays.toString(subSet.toArray(new Integer[0])));
    if (subSet.size()==0) {System.out.println("equals")}
    //如果不想准确判断，判断起点和终点
    Integer[] ai = aSet.toArray(new Integer[0]);
    Integer[] bi = bSet.toArray(new Integer[0]);
    Arrays.sort(ai); //这里如果原来的字符串是排好序的，可以把Set改为List(ArrayList)
    Arrays.sort(bi); //这样这里就不需要重新排序了
    if (ai[0].equals(bi[0]) && ai[ai.length-1].equals(bi[bi.length-1])) {
        System.out.println("equals"); 
    }
}

[杨哥儿]

谢谢阿宝！思路是一样的。
谢谢！！
但计算量有点大！我要检查几万条记录，速度明显受到影响！
有没更好的方法？

[hackya]

顶17楼的,你可以在优化下代码,集合操作几万条记录还是很快的.

[hackya]

小气的女人,一点分都不给大家.