力扣第197场周赛

class Solution {
    public int numIdenticalPairs(int[] nums) {
    　　HashMap<Integer,Integer> index = new HashMap<Integer,Integer>();
    　　int total = 0;
    　　int number;
    　　for (int i=0; i<nums.length; i++) {
       　　index.put(nums[i], index.getOrDefault(nums[i], 0) + 1);
    　　}
    　　for (int key:index.keySet()){    
       　　 total += index.get(key)*(index.get(key) - 1) / 2;
       }
    　　return total;        
    }
}

 

单题总结， 优：使用了哈希表对数据存储进行了优化

　　　　   差：哈希表的getOrDefault操作仍不熟悉

 

class Solution {
    public int numSub(String s) {
        double res = 0;
        double modNum = 1000000007;
        int len = s.length();
        double[] dp = new double[len];
        if(len == 0)
            return 0;
        dp[0] = s.charAt(0) == '1' ? 1 : 0;
        res = dp[0];
        for(int i = 1; i < len; i++) {
            if(s.charAt(i) == '1')
                dp[i] = dp[i-1] + 1;
            else dp[i] = 0;
            res += dp[i];
        }
        return (int)(res%modNum);
    }
}

单体总结， 优：使用了动态规划

           差：未使用Double数据类型，数据取余出错。

也可使用split分割字符串后，用求和公式求解

class Solution {
    public int numSub(String s) {
        String[] strs = s.split("0");
        double max = 0;
        double mode = (int) (Math.pow(10,9) + 7);
        for(String str: strs){
            double a = (double) str.length();
            double b = (double) str.length() + 1;
            max += a*b/2 % mode;
        }
        return (int) max;
    }
}

 

    public static double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
        double max = 0;
        double[] dp = new double[n];
        dp[start] = 1;
        HashMap<Integer,ArrayList<Pair<Integer, Double>>> xianglian = new HashMap<Integer,ArrayList<Pair<Integer, Double>>>();
        for (int i = 0; i < edges.length; i++) {
            if (xianglian.containsKey(edges[i][0])) {
                xianglian.get(edges[i][0]).add(new Pair(edges[i][1],succProb[i]));
            }
            else {
                xianglian.put(edges[i][0], new ArrayList());
                xianglian.get(edges[i][0]).add(new Pair(edges[i][1],succProb[i]));
            }
            if(xianglian.containsKey(edges[i][1])) {
                xianglian.get(edges[i][1]).add(new Pair(edges[i][0],succProb[i]));
            }
            else {
                xianglian.put(edges[i][1], new ArrayList());
                xianglian.get(edges[i][1]).add(new Pair(edges[i][0],succProb[i]));
            }
        }
        if(!xianglian.containsKey(start) || !xianglian.containsKey(end))
            return 0;
        else {
            Queue<Integer> q = new ArrayDeque<Integer>();
            q.add(start);
            while (!q.isEmpty()) {
                int cur = q.poll();
                for (Pair node : xianglian.get(cur)) {
                    if (dp[cur] * (double)node.getValue() > dp[(int)node.getKey()] ) {
                        q.add((int)node.getKey());
                        dp[(int)node.getKey()] = dp[cur] * (double)node.getValue();
                    }
                }
            }
            return dp[end];
        }
    }

单题总结， 优：使用哈希表，存取邻接矩阵，加快了搜索的效率。                 

           差：该题中自己开始最初使用二维数组存储了两点间权值，导致了超出内存限制。且对于使用Dijkstra算法不够熟练，对于图的相关操作欠缺。

收获：了解到了Pair数据存储方式，能够实现键值对的映射，该题中运用该方法，将邻接矩阵和权值存储在一起，使用getKey获得邻接点，getValue获得权值，减少了内存消耗；了解到了Dijkstra算法。