算法-开放性题

1. 甲乙丙（或ABC），3个人轮流掷（6面）骰子，先掷出6的人获胜，甲获胜的概率是多少？


甲先扔
开放性问题，不限制解法；
精确到小数点 3 位

计算复杂部分建议用编程计算

第一回合获胜：1/6

第二回合获胜：（5/6)^3 * (1/6)

第三回合获胜：（5/6)^3 * （5/6)^3  * (1/6)

。。。。

需要小数点后三位：那么可以选择将前50或者100回合获胜的概率结果进行相加。因为如果再往后进行计算，那么结果也不会改变。至少不会改变前三位的结果

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();

        Double[] doubles = new Double[101];
        solution.getWin(100, doubles);
        System.out.println(JSON.toJSONString(doubles));
        Double d = 0.0;
        for (int i=1; i<101; i++) {
            d += doubles[i];
        }
        System.out.println(d);
        return;
    }

    public void getWin(int n, Double[] d){
        getAwin(n, d);
        return;
    }

    public Double getAwin(int n, Double[] d){
        if (n == 1){
            d[1] = 1.0/6;
            return d[1];
        }
        if (n == 2){
            d[2] = 1.0/6 * (75.0/216);
            d[1] = 1.0/6;
            return d[2];
        }
        d[n] = getAwin(n - 1, d) * (75.0 / 216);
        return d[n];
    }

}

2. 一个长度大小为N的数组，数组中的每个元素的取值范围在[1，N]，且为正整数，统计无序数组各元素出现的次数。 o(n) o(1)   

input: 2 5 5 3 3 3 1

output： 2 -> 1 5 -> 2 3 -> 3 1 -> 1 

要求：时间复杂度O(n)，空间复杂度O(1)

tips:

1. 长度大小为N，元素范围为1-N，那么直接可以调整值。 将索引对应的值调整为出现的次数

2. 如何判断当前是出现的次数，还是原先的值。采用数值法【出现次数为负值】

    public int[] getCount(int[] array){

        int tmp = array[0];
        array[0] = 0;

        boolean flag = false;
        while (true){

            flag = false;
            int tmp1 = array[tmp-1];
            if (array[tmp-1] >= 0){
                array[tmp-1] = -1;
            }else{
                array[tmp-1]--;
            }
            System.out.println(JSON.toJSONString(array));
            if (tmp1 <= 0){
                for (int i=array.length-1; i>=0; i--){
                    if (array[i] > 0){
                        tmp1 = array[i];
                        System.out.println(tmp1);
                        array[i] = 0;
                        flag = true;
                        break;
                    }
                }
                if (flag == false){
                    break;
                }
            }

            tmp = tmp1;
        }
        return array;
    }

3.  1-10亿个整数，在文件里面。系统内存限制在1M里面，请找出所有重复的数据

1G=1024M

1M=1024K

1K=1024B(字节)

1.  位图思想，1M可以存储 8*1024*1024个bit = 800万。  我们进行分区见 0 - 800万个bit。分别计算0-800万数据出现的次数。只要出现填充即可，下次填充即可判断是否内容，如果有，立即输出，可以认为是重复

2. 同样的，使用分而治之的思想，这样做的目的是为了将范围降低。一次读写所有的数据将数据分别写入多个文件即可