11.3-11.8

11.3日

941.有效的山脉数组

class Solution {
    public boolean validMountainArray(int[] A) {
    //从左边开始向右找最高峰，找到最高峰后开始向右判断，看是否递减，且避免单调递增递减情况出现
        if(A.length < 3 || A[0] > A[1]) {  //若数组只有两个元素则肯定不满足，且避免数组是递增数组
            return false;
        }
        int height = 0;  //记录最高峰
        for(int i = 1; i < A.length; i ++) {
            if(A[i] > A[i-1]) {
                height = i;
            } else if(A[i] == A[i-1]){
                return false;
            } else {
                break;
            }
        }
        if(height == A.length-1) {  //避免数组是递减数组
            return false;
        }
        for(int i = height+1; i < A.length; i ++) {
            if(A[i] > A[i-1]) {
                return false;
            }else if(A[i] == A[i-1]){
                return false;
            }
        }
        return true;
    }
}

class Solution {
    public boolean validMountainArray(int[] A) {
    //双指针，分别从左右开始向最高峰前进，最后判断最高峰是否一致且是否是单调递增或递减数组
        int left = 0;
        int right = A.length - 1;
        while(left + 1 < A.length && A[left] < A[left+1]) {
            left ++;
        }
        while(right > 0 && A[right] < A[right-1]) {
            right --;
        }
        return left < A.length-1 && right > 0 && left == right;
    }
}

11.4日

57.插入区间

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        ArrayList<int[]> list = new ArrayList<>();
        int len = intervals.length;
        int index = 0;
        // 添加新区间左边的区间
        while(index < len && newInterval[0] > intervals[index][1]) {
            list.add(intervals[index]);
            index ++;
        }
        // 添加新区见，如果有重合则合并重合区间
        while(index < len && newInterval[1] >= intervals[index][0]) {
            newInterval[0] = Math.min(newInterval[0], intervals[index][0]);
            newInterval[1] = Math.max(newInterval[1], intervals[index][1]);
            index ++;
        }
        list.add(newInterval);
        // 添加新区见右边的区间
        while(index < len && newInterval[1] < intervals[index][0]) {
            list.add(intervals[index]);
            index ++;
        }
        return list.toArray(new int[0][]);
    }
}

11.5日

127.单词接龙

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        //wordSet记录所有单词，除了beginWord
        Set<String> wordSet = new HashSet<>(wordList);
        if(wordSet.size() == 0 || !wordSet.contains(endWord)) {
            return 0;
        }
        wordSet.remove(beginWord);
        //len记录步数
        int len = 1;
        //queue记录广度搜素得到的单词
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        //visited和queue记录一样的内容，只是用来使用contains方法，确定某单词是否已经加入过
        Set<String> visited = new HashSet<>();
        visited.add(beginWord);
        while(!queue.isEmpty()) {
            int currentSize = queue.size();
            for (int i = 0; i < currentSize; i++) {
                String word = queue.poll();
                if(judge(word, endWord, wordSet, visited, queue)) {
                    return len + 1;
                }
            }
            len ++;
        }
        return 0;
    }
	//依次更改该单词的所有字母，然后看单词表里有没有这个更改过的单词，有则加入queue
    public boolean judge(String word, String endWord, Set<String> wordSet, Set<String> visited, Queue<String> queue) {
        char[] charArray = word.toCharArray();
        for (int i = 0; i < endWord.length(); i++) {
            char c = charArray[i];
            for (char k = 'a'; k <= 'z'; k++) {
                if (k == c) {
                    continue;
                }
                charArray[i] = k;
                String nextWord = String.valueOf(charArray);
                //如果该单词在单词表中
                if (wordSet.contains(nextWord)) {
                	//如果该单词为endWord则结束，返回结果
                    if (nextWord.equals(endWord)) {
                        return true;
                    }
                    if (!visited.contains(nextWord)) {
                        queue.add(nextWord);
                        visited.add(nextWord);
                    }
                }
            }
            //该字母变完了，没有相应的结果，则变回去，继续变下一个字母
            charArray[i] = c;
        }
        return false;
    }
}

11.6日

1356.根据数字二进制下1的数目排序

class Solution {
    //sum[i]表示数i转换为二进制数后，有几个1
    int[] sum;
    public int[] sortByBits(int[] arr) {
        sum = new int[10001];
        for(int i = 0; i < sum.length; i ++) {
            sum[i] = -1;
        }
        sum[0] = 0;
        //count记录arr中对应下标的数转换为二进制数后，有几个1
        int[] count = new int[arr.length];
        for(int i = 0; i < arr.length; i ++) {
            count[i] = binaryNum(arr[i]);
        }
        
        for(int i = arr.length-1; i >= 0; i--) {
            for(int j = 0; j < i; j ++) {
                if(count[j] > count[j+1] || (count[j]==count[j+1] && arr[j]>arr[j+1])) {
                    int temp = count[j];
                    count[j] = count[j+1];
                    count[j+1] = temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;

    }
    //计算a转换为二进制数后，有几个1
    public int binaryNum(int a) {
        if(sum[a] != -1) {
            return sum[a];
        }
        sum[a] = a%2 + binaryNum(a/2);
        return sum[a];
    }
}

11.7日

27.移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
        int t = 0;
        for(int i = 0; i < nums.length; i ++) {
            if(nums[i] != val) {
                nums[t] = nums[i];
                t ++;
            }
        }
        return t;
    }
}

739.每日温度

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int[] day = new int[T.length];
        for(int i = 0; i < T.length - 1; i ++) {
            int tem = T[i];
            for(int j = i + 1; j < T.length; j ++) {
                if(T[j] > tem) {
                    day[i] = j - i;
                    break;
                }
            }
        }
        return day;
    }
}

11.8日

122.买卖股票的最佳时机Ⅱ

class Solution {
    public int maxProfit(int[] prices) {
        int money = 0;
        for(int i = 0; i < prices.length-1; i ++) {
            if(prices[i+1] > prices[i]) {
                money += prices[i+1] - prices[i];
            }
        }
        return money;
    }
}