算法刷题记录(LeetCode 180-210)

*188. Best Time to Buy and Sell Stock IV

class Solution {
    public static int MIN_VALUE= (int) -1e6;
    public int maxProfit(int k, int[] prices) {
        int times=prices.length;
        int [][][] dp=new int[times+1][k+2][2];
        for (int i=0;i<times;i++){
            for (int j=0;j<=k+1;j++){
                Arrays.fill(dp[i][j],MIN_VALUE);
            }
        }
        for (int j=1;j<=k+1;j++){
            dp[0][j][0]=0;
        }
        for (int i=0;i<times;i++){
            for (int j=1;j<=k+1;j++){
                dp[i+1][j][0]=Math.max(dp[i][j][0],dp[i][j-1][1]+prices[i]);
                dp[i+1][j][1]=Math.max(dp[i][j][1],dp[i][j][0]-prices[i]);
            }
        }
        return dp[times][k+1][0];
    }
}

190. Reverse Bits

    public int reverseBits(int n) {
        int[] res=new int[32];
        for (int i=0;i<32;i++){
            res[i]=n>>i&1;
        }
        int val=0;
        for (int i=0;i<31;i++){
            val+=res[i];
            val = val<<1;
        }
        val+=res[31];
        return val;
    }

更好地解法

    public int reverseBits(int n) {
        int[] res=new int[32];
        int val=0;
        for (int i=0;i<32;i++){
            res[i]=n>>i&1;
            val = val |(res[i]<<(31-i));
        }
        return val;
    }

202. Happy Number

    public boolean isHappy(int n) {
        HashSet<Integer> set=new HashSet<>();
        while (true){
            int sum=0;
            while (n>0){
                int curr=n%10;
                n/=10;
                sum+=curr*curr;
            }
            if (sum==1){
                return true;
            }
            if (set.contains(sum)){
                return false;
            }
            n=sum;
            set.add(sum);
        }
    }

*201. Bitwise AND of Numbers Range

    public int rangeBitwiseAnd(int left, int right) {
        if (left==right){
            return left;
        }
        int res=left^right;
        int count=0;
        for (int i=31;i>=0;i--){
            if (res>>i!=0){
                break;
            }
            count++;
        }
        count=32-count;
        return (right>>count)<<count;
    }

203. Remove Linked List Elements

    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy=new ListNode(1);
        dummy.next=head;
        ListNode prev=dummy;
        ListNode curr=head;
        while (curr!=null){
            if (curr.val==val){
                prev.next=curr.next;
                curr=curr.next;
            }
            else{
                prev=curr;
                curr=curr.next;
            }
        }
        return dummy.next;
    }

204. Count Primes

    public int countPrimes(int n) {
        boolean[] bits=new boolean[n+1];
        for (int i=2;i<=n/2;i++){
            if (!bits[i]){
                int j=i*2;
                while (j<n){
                    bits[j]=true;
                    j+=i;
                }
            }
                
        }
        int count=0;
        for (int i=2;i<n;i++){
            if (!bits[i]){
                count++;
            }
        }
        return count;
    }

205. Isomorphic Strings

    public boolean isIsomorphic(String s, String t) {
        HashMap<Character,Character> map=new HashMap<>(26);
        for (int i=0;i<t.length();i++){
            if (map.containsKey(s.charAt(i))&&map.get(s.charAt(i))!=t.charAt(i)){
                return false;
            }
            else  if (!map.containsKey(s.charAt(i))&& map.containsValue(t.charAt(i))){
                return false;
            }
            else if (!map.containsKey(s.charAt(i))){
                map.put(s.charAt(i),t.charAt(i));
            }
        }
        return true;
    }

206. Reverse a Linked List

    public ListNode reverseList(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode prev=null;
        ListNode curr=head;
        ListNode next;
        while(curr!=null){
            next = curr.next;
            curr.next=prev;
            prev=curr;
            curr=next;
            
        }
        return prev;
    }

207. Course Schedule

class Solution {
    public static HashSet<Integer> visited=new HashSet<>();
    public static HashSet<Integer> overallVisited=new HashSet<>();
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        visited.clear();
        overallVisited.clear();
        int[] courses=IntStream.range(0,numCourses).toArray();
        HashMap<Integer,ArrayList<Integer>> prerequisitesMap=new HashMap<>();
        for(var c:courses){
            prerequisitesMap.put(c,new ArrayList<>());
        }
        for(var arr:prerequisites){
            prerequisitesMap.get(arr[0]).add(arr[1]);
        }
        for(int course:courses){
            if(overallVisited.contains(course)){
                continue;
            }
            if(!dfs(course,prerequisitesMap)){
                return false;
            }
        }
        return true;
    }
    public boolean dfs(int course,HashMap<Integer,ArrayList<Integer>> prerequisitesMap){
        overallVisited.add(course);
        if(visited.contains(course)){
            return false;
        }
        if(prerequisitesMap.get(course).isEmpty()){
            return true;
        }
        visited.add(course);
        var currPrerequisites=prerequisitesMap.get(course);
        for(int c:currPrerequisites){
            if(!dfs(c,prerequisitesMap)){
                return false;
            }
        }
        visited.remove(course);
        prerequisitesMap.get(course).clear();
        return true;
    }
}

208. Implement Trie (Prefix Tree)

    public static class TrieNode{
        public HashMap<Character,TrieNode> children=new HashMap<>();
        public boolean endOfWord=false;
    }
    public TrieNode root=new TrieNode();
    public Trie() {

    }
    public void insert(String word) {
        var curr=root;
        for(int i=0;i<word.length();i++){
            if (!curr.children.containsKey(word.charAt(i))){
                curr.children.put(word.charAt(i),new TrieNode());
            }
            curr=curr.children.get(word.charAt(i));
        }
        curr.endOfWord=true;
    }

    public boolean search(String word) {
        var curr=root;
        for (int i=0;i<word.length();i++){
            if (curr.children.containsKey(word.charAt(i))){
                curr=curr.children.get(word.charAt(i));
            }
            else {
                return false;
            }
        }
        return curr.endOfWord;
    }

    public boolean startsWith(String prefix) {
        var curr=root;
        for (int i=0;i<prefix.length();i++){
            if(!curr.children.containsKey(prefix.charAt(i))){
                return false;
            }
            curr=curr.children.get(prefix.charAt(i));
        }
        return true;
    }

*209. Minimum Size Subarray Sum

    public int minSubArrayLen(int target, int[] nums) {
        int minLength=111111;
        int left=0;
        int right=0;
        int sum=0;
        int currLength=0;
        while (right<nums.length){
            target-=nums[right];
            if (target<=0){
                currLength=right-left+1;
                minLength=Math.min(currLength,minLength);
            }
            while (target<=0){
                target+=nums[left];
                left++;
                minLength=Math.min(minLength,right-left+2);

            }
            right++;
        }
        if (minLength==111111){
            return 0;
        }
        return minLength;
    }