package org.springblade.common.utils;

import java.util.*;

public class MathUtil {

/*    public static void main(String[] args) {
        String[] array = new String[] {"1","2","3"};
        List arrayList = Arrays.asList(array);
        Set<String> resultSet = new HashSet<>();
        getCombination(arrayList, resultSet);
        System.out.println("组合数 = " + resultSet.size());
        System.out.println("所有组合 : " + resultSet);
    }*/


    /**
     * 循环递归获取给定数组元素(无重复)的全排列
     *
     * @param oriList 原始数组
     * @param oriLen 原始数组size
     * @param arrayCombResult 数组排列结果集，可传null或空Set
     * @param preList 记录排列参数，可传null或空List
     * @return 排列结果
     */
    public static Set<String> getArrange(List oriList, int oriLen, Set<String> arrayCombResult, List preList){
        if (oriList == null){
            return arrayCombResult;
        }
        if (arrayCombResult == null){
            arrayCombResult = new HashSet<>();
        }
        if (preList == null){
            preList = new ArrayList();
        }
        for (int i = 0; i < oriList.size(); i++){
            while(preList.size() > 0 && oriList.size() + preList.size() > oriLen){
                preList.remove(preList.size() - 1);
            }
            List arrList = new ArrayList(oriList);
            preList.add(arrList.get(i));
            arrList.remove(i);
            if (arrList.isEmpty()){
                arrayCombResult.add(getStrFromList(preList));
            }else {
                getArrange(arrList, oriLen, arrayCombResult, preList);
            }
        }
        return arrayCombResult;
    }
    /**
     * 循环递归获取给定数组元素(无重复)的所有组合
     *
     * @param oriList 原始数组
     * @param resultSet 元素组合结果，可传null或空set
     * @return 组合结果
     */
    public static Set<String> getCombination(List oriList, Set<String> resultSet) {
        if (oriList == null) {
            return resultSet;
        }
        if (resultSet == null){
            resultSet = new HashSet<>();
        }
        for (int i = 0; i < oriList.size(); i++) {
            List copyList = new ArrayList(oriList);
            resultSet.add(getStrFromList(copyList));
            List removeIList = new ArrayList();
            copyList.remove(i);
            removeIList.addAll(copyList);
            getCombination(removeIList, resultSet);
        }
        return resultSet;
    }
    /**
     * 将数组元素转化为逗号分隔的字符串
     *
     * @param oriList 原始数组
     * @return 字符串
     */
    public static String getStrFromList(List oriList){
        StringBuffer result = new StringBuffer();
        if (oriList == null){
            return result.toString();
        } else {
            for (int i = 0; i < oriList.size(); i++){
                result.append(oriList.get(i));
                if (i != (oriList.size() - 1)){

                }
            }
        }
        return result.toString();
    }



    /**
     * @param args
     */
    private static int min(int one, int two, int three) {
        int min = one;
        if(two < min) {
            min = two;
        }
        if(three < min) {
            min = three;
        }
        return min;
    }

    public static int ld(String str1, String str2) {
        int d[][]; //矩阵
        int n = str1.length();
        int m = str2.length();
        int i; //遍历str1的
        int j; //遍历str2的
        char ch1; //str1的
        char ch2; //str2的
        int temp; //记录相同字符,在某个矩阵位置值的增量,不是0就是1
        if(n == 0) {
            return m;
        }
        if(m == 0) {
            return n;
        }
        d = new int[n+1][m+1];
        for(i=0; i<=n; i++) { //初始化第一列
            d[i][0] = i;
        }
        for(j=0; j<=m; j++) { //初始化第一行
            d[0][j] = j;
        }
        for(i=1; i<=n; i++) { //遍历str1
            ch1 = str1.charAt(i-1);
            //去匹配str2
            for(j=1; j<=m; j++) {
                ch2 = str2.charAt(j-1);
                if(ch1 == ch2) {
                    temp = 0;
                } else {
                    temp = 1;
                }
                //左边+1,上边+1, 左上角+temp取最小
                d[i][j] = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+temp);
            }
        }
        return d[n][m];
    }

    public static double sim(String str1, String str2) {
        int ld = ld(str1, str2);
        return 1 - (double) ld / Math.max(str1.length(), str2.length());
    }

/*   public static void main(String[] args) {
        double data1 =0.19047619047619047;
        double data2 =0.33333333333333337;
       // System.out.println("ld="+ld(str1, str2));
        System.out.println(data1<data2);
    }*/
}
