LeetCodeWeek Contest 151

最新推荐文章于 2020-02-26 17:58:22 发布

原创最新推荐文章于 2020-02-26 17:58:22 发布 · 301 阅读

0 ·

CC 4.0 BY-SA版权

leetcode与剑指Offer 专栏收录该内容

222 篇文章

订阅专栏

本文探讨了三种算法挑战：识别无效交易，通过最小字符频率比较字符串，以及从链表中移除零和连续节点。解决方案涉及复杂的数据结构操作和高效的算法设计。

1169. Invalid Transactions
两种情况，先用遍历一遍数组找出单价大于1000的，然后找在异城同名在60min以内的两个交易

class Solution {
    public List<String> invalidTransactions(String[] transactions) {
        
        HashSet<String> candiadates=new HashSet<>();
        ArrayList<String[]> record=new ArrayList<>();
        int n=transactions.length;
        for(String s:transactions){
            String[] arr=s.split(",");
            record.add(arr);
            if(Integer.valueOf(arr[2])>1000)
                candiadates.add(s);
        }
        for(int i=0;i<n-1;i++){
            String name=record.get(i)[0],city=record.get(i)[3];
            int time=Integer.valueOf(record.get(i)[1]);
            for(int j=i+1;j<n;j++){
                String name1=record.get(j)[0],city1=record.get(j)[3];
                int time1=Integer.valueOf(record.get(j)[1]);
                if(name1.equals(name) && !city.equals(city1) && Math.abs(time-time1)<=60){
                    candiadates.add(transactions[i]);
                    candiadates.add(transactions[j]);
                }
            }
        }
        return new ArrayList<>(candiadates);
    }
}

1170. Compare Strings by Frequency of the Smallest Character

class Solution {
    public int[] numSmallerByFrequency(String[] queries, String[] words) {
        
        int n=words.length;
        int[][] record=new int[n][26];
        int[] count=new int[n];
        char[] chars=new char[n];
        
        for(int k=0;k<n;k++){
            String s=words[k];
            for(int i=0;i<s.length();i++){
                record[k][s.charAt(i)-'a']++;
            }
            for(int i=0;i<26;i++){
                if(record[k][i]!=0){
                    count[k]=record[k][i];
                    break;
                }
            }            
        }
        Arrays.sort(count);
        int m=queries.length;
        int[][] test=new int[m][26];
        int[] count1=new int[m];
        for(int k=0;k<m;k++){
            String s=queries[k];
            for(int i=0;i<s.length();i++){
                test[k][s.charAt(i)-'a']++;
            }
            int index=0;
            for(int i=0;i<26;i++){
                if(test[k][i]!=0)
                {
                    count1[k]=test[k][i];
                    break;
                }
            }
        }
        int[] ans=new int[m];
        for(int i=0;i<m;i++){
            int t=count1[i];
            int l=0,r=n-1;
            if(t>=count[r]){
                ans[i]=0;
                continue;
            }
            while(l<r){
                int mid=(l+r)>>1;
                if(count[mid]>t)
                    r=mid;
                else
                    l=mid+1;
            }
            //System.out.println(r);
            ans[i]=n-r;
        }
         return ans;
    }

1171. Remove Zero Sum Consecutive Nodes from Linked List
前缀和

class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
        ListNode virtual=new ListNode(0);
        virtual.next=head;
        HashMap<Integer,ListNode> map=new HashMap<>();
        map.put(0,virtual);
        ListNode cur=virtual;
        int sum=0;
        while(cur.next!=null)
        {
            cur=cur.next;
            sum += cur.val;
            if(map.containsKey(sum))
                map.get(sum).next=cur.next;
            else
                map.put(sum,cur);
        }
        return virtual.next;
    }
}

1172. Dinner Plate Stacks

class DinnerPlates {

    public int maxCapacity;
    public ArrayList<Stack<Integer>> stacks;
    public TreeSet<Integer> slotIndex;  //有空位的栈的索引
    public TreeSet<Integer> outIndex;  //含有元素的栈的索引
    
    public DinnerPlates(int capacity) {
        
        this.maxCapacity=capacity;
        stacks=new ArrayList<>();
        slotIndex=new TreeSet<>();
        outIndex=new TreeSet<>((a,b)->b-a);
        
    }
    
    public void push(int val) {
        int slot=slotIndex.size()==0?stacks.size():slotIndex.pollFirst();
        if(slot<stacks.size()){
            Stack<Integer> st=stacks.get(slot);
            st.push(val);
            if(st.size()<maxCapacity)
                slotIndex.add(slot);
        }
        else{
            Stack<Integer> st=new Stack<>();
            st.add(val);
            if(st.size()<maxCapacity)
                slotIndex.add(slot);
            stacks.add(st);
        }
        outIndex.add(slot);
    }
    
    public int pop() {
        if(outIndex.size()==0)
            return -1;
        int slot=outIndex.first();
        int ans=stacks.get(slot).pop();
        if(stacks.get(slot).size()==0)
            outIndex.pollFirst();
        slotIndex.add(slot);
        return ans;
    }
    
    public int popAtStack(int index) {
        if(index>=stacks.size() || stacks.get(index).size()==0)
            return -1;
        int ans=stacks.get(index).pop();
        slotIndex.add(index);
        return ans;
    }
}