78. Subsets

思路1：深度优先搜索：每个位置都有选，和 不选两种选择。退出条件是下标出界。

    public List<List<Integer>> subsetsV3(int[] nums) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        dfs(result, list, nums, 0);
        return result;
    }

    private void dfs(List<List<Integer>> result, List<Integer> list, int[] nums, int idx) {
        if(idx==nums.length){
            result.add(new ArrayList<Integer>(list));
            return;
        }
        dfs(result, list, nums, idx+1);
        list.add(nums[idx]);
        dfs(result, list, nums, idx+1);
        list.remove(list.size()-1);
    }

思路2：使用位操作。有一个二进制数组，对应数组中每个元素是不是选择。例如数组[1,2,3]，有一个二进制数组[0,0,0]表示一个元素都不选择;[0,0,1]选择nums[0]元素;[0,1,0]选择nums[1]元素；依次….

    public List<List<Integer>> subsetsV2(int[] nums) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        int n = nums.length;
        int total = (1 << n) - 1;// 2^n-1
        for (int i = 0; i <= total; i++) {
            List<Integer> list = new ArrayList<Integer>();
            for(int j=0;j<n;j++){
                if(((i>>j) &1)==1){
                    list.add(nums[j]);
                }
            }
            result.add(list);
        }
        return result;
    }

代码

90. Subsets II

思路：与78的深度优先搜索思路相同，只是要自己试试看哪些情况下出现重复的情况，在深度优先搜索过程中去掉这些情况。
代码

729 My Calendar I

思路：挨个比较
学习：放在map中，floorKey(key)：比key小的最大值，ceilingKey(key):比key大的最小的值
代码

611 Valid Triangle Number

思路：这道题目首先会想到用深度优先搜索。每个位置的元素可以选择或者不选择。这样肯定能解决，问题是会超时。这时候肯定是需要观察，找规律。很遗憾，我没找到规律。
学习：条件是：三角形任意两边之和＞第三边。如果两个小的边的和＞最长的边，那一定符合要求。先确定最大的边：数组排序，下标最大的就是最大的边。
例如数组[2,2,3,4]。如果i=3，接着使用两个指针l=0，r=2；如果nums[0]+nums[2]>nums[3]，那么，保持r不变，不断增加l，直到l=r，那这个过程中所有的nums[l]+nums[r]>nums[i]。所以这中间的组合有r-l个。具体来说就是：因为nums[0]+nums[2]>nums[3]符合要求，那么nums[1]+nums[2]>nums[3]肯定符合要求，所以组合数有r-l=2-0=2个。
代码

526 Beautiful Arrangement

思路：深度优先搜索，对于第i个位置，枚举可能使用的数值。可能使用的数值需要满足两个条件： 1 还未被使用；2 能够使得 数值%i=0或者 i%数值=0
学习：思路相同，但是迭代次数更少。
技巧一： backtracing从后面开始，这样每个搜索在失败之前都不会太深，因为较小的数字有更大的机会在他们自己之间被分割。解释是这样的。如果start从小到大，假如 start=1,nums[1]=4 ，那么4%1=0成立；start=4,nums[4]=3，那么4%3=0 或者 3%3=0都不成立；如果start从大到小，假如start=4， nums[4]=3，那么4%3=0 或者 3%3=0都不成立;则就不可能再去判断 nums[4]=3情况下： start=3,2,1的情况了，这样就会减少调用次数。
技巧二：Also I don’t use “visited” boolean array but use swap of an array of 1~N to avoid duplication.第start位能够选择的数字在nums[1~start]这些位置上的数字选择，每当选择一个，就把这个数字放在nums[start]位置上。这样别的位置就不能再选择这个数字了。聪明。

    public int countArrangementV2(int N) {
        if (N == 0)
            return 0;
        int[] nums = new int[N + 1];
        for (int i = 0; i <= N; i++)
            nums[i] = i;
        helper(nums, N);
        return count;
    }
    private void helper(int[] nums, int start) {
        if (start == 0) {
            count++;
            return;
        }
        for (int i = start; i > 0; i--) {
            swap(nums, start, i);
            if (nums[start] % start == 0 || start % nums[start] == 0)
                helper(nums, start - 1);
            swap(nums, i, start);
        }
    }
    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

代码

667 Beautiful Arrangement II

思路：深度优先搜索，为每个位置上取值，再判断是否符合条件。超时。继续观察。想到差值最小是1，最大是n-1.如果 $k<n-1$怎么处理？我想到的是随机取。然后就思考不下去了。
学习：如果 $k<n-1$，那就先取k-1个差值：n-1,n-2….，最后的一个差值取1。
1,n,2,n-1,3,n-2,4… ==> Diff: n-1, n-2, n-3, n-4, n-5… k个数有k-1个不同的差值。
例如n=9，k=5，则取数据：1 9 2 8 3 4 5 6 7
例如n=9，k=6，则取数据：1 9 2 8 3 7 6 5 4
代码

238 Product of Array Except Self

思路：这道题目如果允许除法，很简单；如果是O(n^2)也很简单。所有数相乘，只是不乘以对应下标中nums[i]这个数。但是当要求不用除法，O(n)时间复杂度，就没有思路了。
给定数组nums={2,3,4,5}。
结果应该是：

我思考到这里，就不知道该怎么做了。

学习：学习了一个思路，太鬼才了。在上面的表格中按1分隔，分为从左边乘和从右边乘。
考虑下标i=2，结果应该是2*3*1*5。这个结果可以看做是左边的2*3，和右边的5相乘得到的结果。

把空的地方填上1

通过两次循环实现。
如果能看到2*3*4=4*3*2也许能想到从右向左。如果能看到以1分隔，分别是nums[i]左边的数字和右边的数字相乘，也许能想到解决方法把。

    public int[] productExceptSelf(int[] nums) {
        int[] result = new int[nums.length];
        int left = 1;
        for (int i = 1; i <= nums.length; i++) {
            result[i-1] = left;
            left *= nums[i - 1];
        }
        int right = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            if(i<nums.length-1){
                right = right * nums[i+1];
            }
            result[i] = result[i] * right;
        }
        return result;
    }

代码

565 Array Nesting

思路：像环的检测， Floyd环之前做过。最简单：把每个i遍历一次，比较长度 。做完之后打印一下环，发现一个环内的元素无论从哪个元素开始，得到的长度都相同。例如nums=[5,4,0,3,1,6,2]。对于{5, 6, 2, 0}这样一个环，从下标0开始，长度是4；从下标2开始，长度还是4。所以需要去重，访问过的就不再访问了。提交后发现超时。
学习：这个时候我又在想我的思路错了？是不是还有更好的思路。看了讨论，发现是在去重那里优化。不需要用额外的空间存储是否访问过；访问过的可以标记为-1，因为初始每个元素是在[0,N-1]之间的。
改进的时候有两种：第一计算方式需要改进，这个时候需要重新观察数据。例如238。第二种是去重方式可以优化。例如本题。
学习2：本题还有用并查集解决的。
nums=[5,4,0,3,1,6,2]

union(0,5)：5的父节点是0：parent[5]=0；

union(1,4)：4的父节点是1：parent[4]=1；

union(2,0)：0的父节点是2：rootP=2，rootQ=0,rank[rootQ] > rank[rootP]=>parent[rootP] = rootQ；

union(3,3)：3的父节点是3：parent[3]=3；

union(4,1)：1的父节点是4：parent[1]=4，parent[4]=1 return；

union(5,6):6的父节点是5：parent[6]=6,parent[5]=0 rank[rootQ] < rank[rootP] =>parent[6]=0

union(6,2): rootP=0,rootQ=0

最终有4处的parent都是0，所以长度为4，是最长的环。

[代码]

(https://github.com/Emma123456/leetcodepractice/blob/master/src/array/ArrayNesting565.java)

769 Max Chunks To Make Sorted

思路：刷leetcode，简直就是在找虐。我想到了，题目要求返回最多的分区数量。那如果每个都可以单独分开是最好的。但是不可以。例如nums=[1,0,2,3,4]，0和1分开的话，排序就不对了，所以0和1必须在一起。那就是说，如果在当前位置i，如果arr[i+1]以及之后的数字都大于0到i位置的元素，那么就能分隔。这样的话，需要O(n^2)的复杂度。应该可以简化。
学习1：因为所有左边的元素 ＜ 右边元素的时候可以形成新的分区，也就是说如果对于i下标：左边元素的最大值 $<$ (i+1)到(n-1)位置的最小元素 =>可以形成新的分区。学习到的思路就是：用maxOfLeft数组，记录当当前位置最大值；而不是拿一个变量找全局最大值。

public int maxChunksToSorted(int[] arr) {
        int n = arr.length;
        int[] maxOfLeft = new int[n];
        maxOfLeft[0] = arr[0];
        for (int i = 1; i < n; i++) {
            maxOfLeft[i] = Math.max(arr[i], maxOfLeft[i - 1]);
        }
        int[] minOfRight = new int[n];
        minOfRight[n - 1] = arr[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            minOfRight[i] = Math.min(arr[i], minOfRight[i + 1]);
        }
        int chunksCount = 0;
        for (int i = 0; i < n - 1; i++) {
            if (maxOfLeft[i] <= minOfRight[i + 1])
                chunksCount++;
        }
        return chunksCount + 1;
    }

学习2：用一个max数组保存到当前位置最大的元素，每个位置的最大元素和已经排序好的数组中的元素比较，如果max[i] = sorted[i]，那在这个位置就可以分割。

在题目中说明arr[i] 在 [0,arr.length - 1]所以排序后的数组一定是0,1,2,….n-1。就可以进一步省略max数组，只需要max变量。这里就是重点理解 max==i。max是到目前位置的最大值；i是排序好以后i位置元素的值。

    public int maxChunksToSortedV2(int[] arr) {
        int count = 0;
        int max = -1;
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr[i]);
            if (max == i) {
                count++;
            }
        }
        return count;
    }

代码