请教一个算法问题。

Question

java算法

Answer 1

要看数据量的多少，如果数据量小的话，直接在内存操作就好了Map<String, Integer>，把每个数组遍历一遍，数据进map统计次数就ok了。如果数据量太大不能在内存操作，可以先用hash算法把数据分成小文件，然后统计单个文件就可以了，因为相同的数据一定在同一个文件里。

Answer 2

Map这个，应该实现不了吧。可能我没有理解你的思路，能否在探讨一下？

Answer 3

String[] str = {"12","121"};
        String[] str1 = {"12","121"};
        String[] str2 = {"12","121","122"};
        String[] str3 = {"123","1234","125","126","111"};
        String[] str4 = {"1234","126","125","1232","111"};
        String[] str6 = {"12","121","222","1433","1234","126","125","1232"};
        Map<String, Integer> m = new HashMap<String, Integer>();
        for (String s : str) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
}
        for (String s : str1) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
}
        for (String s : str2) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
}
        for (String s : str3) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
}
        for (String s : str4) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
} 
        for (String s : str6) {
if(m.containsKey(s)){
m.put(s, m.get(s)+1)  ;
}else{
m.put(s, 1)  ;
}
}
        
        for (Entry<String, Integer> o : m.entrySet()) {
         //if(o.getValue()>1){
         System.out.println(o.getKey()+"---->"+o.getValue());
         //}
}

Answer 4

map 都有了。你 String[] str = {"12","121"}; 里面 12  从map 里面取数据不就有出现次数了。

Answer 5

map里面都是分开存储了，我怎么知道12  和 121  是同时出现的

Answer 6

组合的话，意思就是说：可以随意组合呗。
简单考虑了一下，是不是可以按照数组的length从小到大的顺序，进行遍历呢？

Answer 7

大致思路import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;public class Test {
    
    static String[][] str = {{"12","121"},{"12","121"},{"12","121","122"},{"123","1234","125","126","111"},{"1234","126","125","1232","111"},{"12","121","222","1433","1234","126","125","1232"}};    public static void main(String[] args){
        List<String> str_ = Arrays.asList(str[0]);
        List<String> str1_ = Arrays.asList(str[1]);
        List<String> str2_ = Arrays.asList(str[2]);
        List<String> str3_ = Arrays.asList(str[3]);
        List<String> str4_ = Arrays.asList(str[4]);
        List<String> str5_ = Arrays.asList(str[5]);
        
        System.out.println(str2_.containsAll(str_));
    }
}

Answer 8

map里面都是分开存储了，我怎么知道12  和 121  是同时出现的
哦  ，是一起出来呀。理解错了

Answer 9

你12，121这种内容，数量是否有限？
如果不是很多的话，比如就你这里面一共不超过10种（没仔细数）可以用质数来搞定比如12用质数2代替，121用质数3代替，122变5类推...
那么
String[] str = {"12","121"}; ---> 2 * 3 = 6
String[] str1 = {"12","121"}; ---> 2 * 3 = 6
String[] str2 = {"12","121","122"}; ---> 2 * 3 * 5 = 30然后，要判断12 和 121同时出现，直接拿他们两个对应的质数的乘积，与刚才每个数组所有元素对应的乘积做比较
如果取模（余数）为0，则在这个数组中，两者同时出现。

Answer 10

所以这个似乎 是要 将 一个数组内的所有的排列组合 列出来之后 再用map
比如： String[] str2 = {"12","121","122"}; 列出  “12 121”，“121 122” “12 122” “12 121 122”

Answer 11

5000+个候选人，貌似还是有点多，我那个质数方案不是不能做，就是没法直接用整型，而是要借用BigInteger来做。性能上损失蛮大。我下午再想想

Answer 12

数据量不大可以试试以下
public class test { public static List<List<String>> list = null; public static void main(String[] args) {
String[] str = { "12", "121" };
String[] str1 = { "12", "121" };
String[] str2 = { "12", "121", "122" };
String[] str3 = { "123", "1234", "125", "126", "111" };
String[] str4 = { "1234", "126", "125", "1232", "111" };
String[] str6 = { "12", "121", "222", "1433", "1234", "126", "125",
"1232" };
list = new ArrayList<List<String>>();
list.add(Arrays.asList(str));
list.add(Arrays.asList(str1));
list.add(Arrays.asList(str2));
list.add(Arrays.asList(str3));
list.add(Arrays.asList(str4));
list.add(Arrays.asList(str6));
int result = getCount(new String[] { "12", "121" });
System.out.println(result);
result = getCount(new String[] { "12", "121", "122" });
System.out.println(result);
result = getCount(new String[] { "125", "126", "1234" });
System.out.println(result);
result = getCount(new String[] { "1234", "125", "126", "111" });
System.out.println(result); } public static int getCount(String[] strs) {
int result = 0;
for (List<String> li : list) {
if (li.containsAll(Arrays.asList(strs))) {
result++;
}
}
return result;
}
}

Answer 13

优化下 就可以用了。import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;public class Test {
/**
 * 组合数组元素（不去重）
 * @param strs 数组
 * @param count 按顺序，组合的元素个数
 * @return
 */
public static String[] megerToAry(String[] strs, int count) {
     if (strs.length < count || count <= 0) return null;
 
     int len = strs.length;   
     String[] rs = new String[len - count + 1];
     String str;
     for (int i = 0; i < (len - count + 1); i++) {
     str = "";
     for (int j = i; j < (i + count); j ++) {
     str += strs[j] + ",";
     }
    
     rs[i] = str.substring(0, str.length() - 1);
     }
    
     return rs;
    }

/**
 * 组合数组元素（去重）
 * @param strs 数组
 * @param count 按顺序，组合的元素个数
 * @return
 */
public static Set<String> megerToSet(String[] strs, int count) {
if (strs.length < count || count <= 0) return null;

     int len = strs.length;
     Set<String> rs = new LinkedHashSet<String>();
     String str;
     for (int i = 0; i < (len - count + 1); i++) {
     str = "";
     for (int j = i; j < (i + count); j ++) {
     str += strs[j] + ",";
     }
    
     rs.add(str.substring(0, str.length() - 1));
     }
    
     return rs;
    }

public static void main(String[] args) {
List<String[]> allList = new ArrayList<String[]>();
    
     String[] str = {"12","121"};
        String[] str1 = {"12","121"};
        String[] str2 = {"12","121","122","12","121"};
        String[] str3 = {"123","1234","125","126","111"};
        String[] str4 = {"1234","126","125","1232","111"};
        String[] str5 = {"12","121","222","1433","1234","126","125","1232"};        allList.add(str);
        allList.add(str1);
        allList.add(str2);
        allList.add(str3);
        allList.add(str4);
        allList.add(str5);
        
        int min = 2; // 最少两个元素组合
        Map<String, Integer> rsMap = new HashMap<String, Integer>();
     for (String[] s : allList) {
     for (int i = min; i < (s.length + 1); i++) {
     // 不去重（同一元素组合在同一数组中出现多次;例如数组str2中12,121出现2次）
     for (String item : Test.megerToAry(s, i)) {
     if (rsMap.containsKey(item)) {
     rsMap.put(item, rsMap.get(item) + 1);
     }else{
     rsMap.put(item, 1);
     }
     }
    
//     // 去重
//     for (String item : Test.megerToSet(s, i)) {
//     if (rsMap.containsKey(item)) {
//     rsMap.put(item, rsMap.get(item) + 1);
//     }else{
//     rsMap.put(item, 1);
//     }
//     }
     }
     }     // 需要给重复词数加阈值的，在rsMap中过滤
     for (Object key : rsMap.keySet().toArray()) {
     System.out.println(key + ":" + rsMap.get(key));
     }
}
}

Answer 14

1234,126,125,111这个出现2次  
str3 str4

Answer 15

你这个有问题吧，
比如
12,121,122
1234,126,125,111
这两组就没有统计正确，是分成两组的没有合并这俩个都统计的是：1，请问那不正确了？
12,121,122:1
1234,125,126,111:1
1234,125,126,111有两个吧，这是组合又不是排列。
而且你这个排列都没排列全，你看你那个mergeTo那两个方法
比如一个Set是{1,2,3,4,5}，排列2
你就只能得到12 23 34 45，那13 14 15 24 25 35呢？

Answer 16

String[] str3 = {"123","1234","125","126","111"};
String[] str4 = {"1234","126","125","1232","111"};你说的：1234,126,125,111，从来没出现过！
不要用眼睛去看了，哥哥们！
相信程序，继续顶29楼！

Answer 17

你这个有问题吧，
比如
12,121,122
1234,126,125,111
这两组就没有统计正确，是分成两组的没有合并这俩个都统计的是：1，请问那不正确了？
12,121,122:1
1234,125,126,111:1
1234,125,126,111有两个吧，这是组合又不是排列。
而且你这个排列都没排列全，你看你那个mergeTo那两个方法
比如一个Set是{1,2,3,4,5}，排列2
你就只能得到12 23 34 45，那13 14 15 24 25 35呢？我明白了，是随意组合，不考虑顺序的。。我理解错了 SORRY！

Answer 18

String[] str3 = {"123","1234","125","126","111"};
String[] str4 = {"1234","126","125","1232","111"};你说的：1234,126,125,111，从来没出现过！
不要用眼睛去看了，哥哥们！
相信程序，继续顶29楼！
"1234,126,125,111 一块儿出现2次"
这是楼主自己说的，我相信他说的是组合不是排列，你的代码确实能统计相邻排列，但这不是楼主的要求有什么用。。

Answer 19

两个问题：
1. LZ给的样例，12,121出现4次。如果现在还有一个String[] strX = {"111","12","121"}
这个要算12,121的出现次数么？
2. {"121","12"}这种顺序反过来的，要算在其中么？可否先将每个数组的内容排序，再进行计算？

Answer 20

反正我的电脑 5000个5分钟没反应！！！import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;public class T {
/**
 * 获取组合
 * @param i
 * @param str
 * @param num
 * @param set
 */
private static void count(int i, String str, Integer[] num, Set<String> set) {
        if (i == num.length) {
         set.add(str);
            return;
        }
        
        count(i + 1, str, num, set);
        count(i + 1, str + num[i] + ",", num, set);
    } /**
 * 获取排列
 * @param prefix
 * @param a
 * @param list
 */
    public static void sort(String prefix, Integer[] a, List<String> list) {  
     if (a.length == 1) {  
     list.add(prefix + a[0]);
     }       for (int i = 0; i < a.length; i++) {  
     sort(prefix + a[i], copy(a, i), list);  
     }  
    }      private static Integer[] copy(Integer[] a,int index){  
     Integer[] b = new Integer[a.length-1];  
     System.arraycopy(a, 0, b, 0, index);  
     System.arraycopy(a, index+1, b, index, a.length-index-1);  
     return b;  
   }  
    
public static void main(String[] args) {
List<String[]> allList = new ArrayList<String[]>();     String[] str = {"12","121"};
        String[] str1 = {"12","121"};
        String[] str2 = {"12","121","122","12","121"};
        String[] str3 = {"123","1234","125","126","111"};
        String[] str4 = {"1234","126","125","1232","111"};
        // String[] str5 = {"12","121","222","1433","1234","126","125","1232"}; // 超过5个元素，程序基本就废了
        
        // 500个数组，测试5千个数据时，5分钟没有出来，放弃了。
        for (int x = 0; x < 100; x++) {
         allList.add(str);
            allList.add(str1);
            allList.add(str2);
            allList.add(str3);
            allList.add(str4);
            // allList.add(str5);
        }        // 下面很乱，大体就是先对每个数组排列，再对每个排列组合
        List<String> list;
        Set<String> gSet;
        Integer[] a;
        List<Set<String>> rsList = new ArrayList<Set<String>>();
        List<String> newSortList;
        Set<String> mSet;
        for (String[] ss : allList) {
         list = new ArrayList<String>();
         mSet = new HashSet<String>();
         a = new Integer[ss.length];
         for (int i = 0; i < ss.length; i++) {
         a[i] = i;
         }
         T.sort("", a, list);
         for (String no : list) {
         newSortList = new ArrayList<String>();
         for (String c : no.split("")) {
         if ("".equals(c)) {
         continue;
         }else{
         newSortList.add(ss[Integer.parseInt(c)]);
         }
         }
         gSet = new HashSet<String>();
         T.count(0, "" , a, gSet);
         for (String gn : gSet) {
         String sr = "";
         for (String g : gn.split(",")) {
         if ("".equals(g.trim())) {
         break;
         }else{
         sr += newSortList.get(Integer.parseInt(g)) + ",";
         }
         }
         if (!"".equals(sr))mSet.add(sr);
         }
         }
         rsList.add(mSet);
        }
        
        Map<String, Integer> rsMap = new HashMap<String, Integer>();
        for (Set<String> se : rsList) {
         for (String st : se) {
         if (rsMap.containsKey(st)) {
rsMap.put(st, rsMap.get(st) + 1);
}else{
rsMap.put(st, 1);
}
         }
        }     for (Object key : rsMap.keySet().toArray()) {
     System.out.println(key + ":" + rsMap.get(key));
     }
}
}

Answer 21

方法论不是很懂，但可以得到你要的结果
        static void Main(string[] args)
        {            string[] str = { "12", "121" };
            string[] str1 = { "12", "121" };
            string[] str2 = { "12", "121", "122" };
            string[] str3 = { "123", "1234", "125", "126", "111" };
            string[] str4 = { "1234", "126", "125", "1232", "111" };
            string[] str6 = { "12", "121", "222", "1433", "1234", "126", "125", "1232" };
            List<string[]> la = new List<string[]>();
            la.Add(str);
            la.Add(str1);
            la.Add(str2);
            la.Add(str3);
            la.Add(str4);
            la.Add(str6);
            string[] str5 = { "1234", "126", "125" ,"111"};
            Console.WriteLine(FuncOne(str5, la));
            Console.Read();
        }        private static int FuncOne(string[] abc, List<string[]> la)
        {
            int count = 0;          
            foreach (string[] a in la)
            {
                if (Compare(abc, a))
                {
                    count++;
                }
            }            return count;
        }
        private static bool Compare(string[] abc, string[] la)
        {
            bool flag = false;
            int counttrue = 0;            for (int i = 0; i < abc.Length; i++)
            {
                for (int j = 0; j < la.Length; j++)
                {
                    if (abc[i] == la[j])
                    {
                        counttrue++;
                    }                }
            }            if (abc.Length == counttrue)
            {
                flag = true;
            }            return flag;
        }