LeetCode 第 151 场周赛

一、查询无效交易(LeetCode-1169)

1.1 题目描述

1.2 解题思路

根据，它和另一个城市中同名的另一笔交易相隔不超过 60 分钟（包含 60 分钟整）

得出

城市A和其他城市任何一笔交易，时间的绝对值要大于60分钟才有效，若小于60分钟，则当前交易和其他城市的交易均无效。

理解了这层意思，问题就基本解决了。如果想到所有交易按时间排序，就把问题想复杂了。

1.3 解题代码

public class Solution {

    List<String> res = new ArrayList<>();
    List<Transaction> list = new ArrayList<>();

    class Transaction {
        public String name;
        public int time;
        public int amount;
        public String city;
        public String origin;
    }


    public List<String> invalidTransactions(String[] transactions) {
        //对所有交易按时间排序
        for (String transaction : transactions) {
            list.add(str2Transaction(transaction));
        }

        Map<String, List<Transaction>> map = new HashMap<>();

        for (Transaction transaction : list) {
            //交易金额超过 ¥1000 无效
            if (transaction.amount > 1000) {
                save(transaction.origin);
            }

            //它和另一个城市中同名的另一笔交易相隔不超过 60 分钟
            // 可以理解为其他城市的所有同名交易)
            List<Transaction> temp = map.get(transaction.name);
            if (temp == null) {
                map.put(transaction.name, new ArrayList<>());
            } else {
                for (Transaction a : temp) {
                    //比较是否是同一个城市
                    if (!transaction.city.equals(a.city) && Math.abs(transaction.time - a.time) <= 60) {
                        save(transaction.origin);
                        save(a.origin);
                    }
                }
            }
            map.get(transaction.name).add(transaction);
        }

        return res;
    }

    //字符串转换为交易对象
    private Transaction str2Transaction(String transaction) {
        Transaction transaction1 = new Transaction();
        String[] fields = transaction.split(",");
        transaction1.name = fields[0];
        transaction1.time = Integer.valueOf(fields[1]);
        transaction1.amount = Integer.valueOf(fields[2]);
        transaction1.city = fields[3];
        transaction1.origin = transaction;
        return transaction1;
    }

    //去重保存结果
    private void save(String str) {
        if (!res.contains(str)) {
            res.add(str);
        }
    }


}

优化后的写法

public List<String> invalidTransactions(String[] transactions) {
          List<String> res = new ArrayList<>();
        if (transactions.length == 0) {
            return res;
        }

        Map<String, List<Integer>> map = new HashMap<>();
        int len = transactions.length;
        //存放交易索引，用于去重处理
        int[] resArray = new int[len];
        for (int i = 0; i < len; i++) {
            String[] field = transactions[i].split(",");

            //交易金额超过 ¥1000 无效
            if (Integer.valueOf(field[2]) > 1000) {
                resArray[i] = 1;
            }
            //它和另一个城市中同名的另一笔交易相隔不超过 60 分钟
            // 可以理解为其他城市的所有交易
            if (map.get(field[0]) == null) {
                map.put(field[0], new ArrayList<>());
            } else {
                for (int j : map.get(field[0])) {
                    String[] fieldTemp = transactions[j].split(",");
                    // 比较城市名称与相差的时间
                    if (!field[3].equals(fieldTemp[3]) && Math.abs(Integer.valueOf(field[1]) - Integer.valueOf(fieldTemp[1])) <= 60) {
                        resArray[i] = 1;
                        resArray[j] = 1;
                    }
                }
            }
            map.get(field[0]).add(i);
        }
      
        for (int i = 0; i < len; i++) {
            if(resArray[i] == 1){
                res.add(transactions[i]);
            }   
        }

        return res;
    }

二、比较字符串最小字母出现频次(LeetCode-1170)

三、从链表中删去总和值为零的连续节点(LeetCode-1171)

转载于:https://www.cnblogs.com/fonxian/p/11420817.html