7月算法训练------第二十六天（并查集）解题报告

7月算法训练------第二十六天（并查集）解题报告

题目类型：并查集
题目难度：中等

第一题、面试题 17.07. 婴儿名字

1. 题目链接：面试题 17.07. 婴儿名字
2. 思路分析：
   并查集
   这一题题中说有些名字可以按一种算，这种要求就表明，有些不同的名字其实是一样的，要按同一种来算，即我们可以设置一个同根的名字族，按这种思路，就和并查集的思路很相似。同根的算作一种，我们要先初始化这个并查集，就是将每个名字的父结点都先初始化为自己，然后按synonyms数组中的关系，改变节点之间的依赖关系，让相通的名字都有相同父节点，这个父节点我们应尽量选择长度较短的作为父节点。
   为了实现这一功能，我们需要将找父节点这个功能写成一个单独的方法：find()方法。
   当我们处理好所有的并查集后，就需要遍历names数组，将其中的值加起来。首先，应将其中的字符串中的数字分离出来，然后判断当前名字与HashMap中的每个元素是否同根，如果同根，直接加上，如果不同根，则将当前字符串加进HashMap中。
   最后用一个ArrayList将所有的结果变成数组返回。
3. 代码：

class Solution {
    Map<String, String> map;
    public String[] trulyMostPopular(String[] names, String[] synonyms) {
        Map<String, Integer> cnt = new HashMap();
        map = new HashMap();
        for(String name : names){
            int i = 0;
            while(name.charAt(i) != '(') i++;
            map.put(name.substring(0, i), name.substring(0, i));
        }
        for(String name : synonyms){
            String[] temp = name.split(",");
            String x = temp[0].substring(1,temp[0].length());
            String y = temp[1].substring(0, temp[1].length() - 1);

            if(!map.containsKey(x)) map.put(x, x);
            if(!map.containsKey(y)) map.put(y, y);

            String fx = find(x);
            String fy = find(y);

            if(!fx.equals(fy)){
                if(fx.compareTo(fy) > 0) {
                    map.put(fx, fy);
                }else{
                    map.put(fy, fx);
                }
            }
        }

        for(String name : names) {
            int i = 0;
            while(name.charAt(i) != '(') i++;

            String root = find(name.substring(0, i));
            cnt.put(root, cnt.getOrDefault(root, 0) + Integer.parseInt(name.substring(i + 1, name.length() - 1)));
        }

        List<String> list = new ArrayList<>();
         for (String str : cnt.keySet()) {
            list.add(str + "(" + cnt.get(str) + ")");
            }
        return list.toArray(new String[0]);


    }
    public String find(String x) {
        if(!map.get(x).equals(x)) {
            map.put(x, find(map.get(x)));
        }

        return map.get(x);
    }
}

剑指offer动态规划

第二题、剑指 Offer 10- I. 斐波那契数列

1. 题目链接：剑指 Offer 10- I. 斐波那契数列
2. 思路分析：
   这一题算是动态规划的经典入门题目了。
   用数组a表示这个动态规划数组，它的第i位的值是第i-1位和第i-2位值的和，然后每一步都做一个取模运算。
3. 代码：

class Solution {
    private static final int mod = (int)1e9+7;
    public int fib(int n) {
        if(n == 1) return 1;
        if(n == 0) return 0;
        if(n == 2) return 1;
        long[] a = new long[n];
        a[0] = 1;
        a[1] = 1;
        for(int i = 2; i < n; i++){
            a[i] = (a[i-1] + a[i-2]) % mod;
        }
        return (int)(a[n-1] % mod);
    }
}

第三题、剑指 Offer 10- II. 青蛙跳台阶问题

1. 题目链接：剑指 Offer 10- II. 青蛙跳台阶问题
2. 思路分析：
   这一题和斐波那契数列其实都是一样的。
3. 代码：

class Solution {
    private static final int mod = (int) 1e9+7;
    public int numWays(int n) {
        if(n == 0) return 1;
        int[] bp = new int[n+1];
        bp[0] = 1;
        bp[1] = 1;
        for(int i = 2; i < n+1; i++){
            bp[i] = (bp[i-1] + bp[i-2]) % mod;
        }
        return bp[n];
    }
}

第四题、剑指 Offer 63. 股票的最大利润

1. 题目链接：剑指 Offer 63. 股票的最大利润
2. 思路分析：
   用一个minPrice来记录当前天之前的最小价格，然后用当前的股票价格减去最小值，就是当前天卖出去所能得到的利润，然后将真个bp数组排序，返回最大值就是答案。
3. 代码：

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length == 0) return 0;
        int[] bp = new int[prices.length];
        bp[0] = 0;
        int minPrice = prices[0];
        for(int i = 1; i < bp.length; i++){
            if(prices[i] < minPrice){
                minPrice = prices[i];
            }
            bp[i] = prices[i] - minPrice;
        }
        Arrays.sort(bp);
        return bp[prices.length - 1];
    }
}