Invalid Transactions

A transaction is possibly invalid if:

the amount exceeds $1000, or;
if it occurs within (and including) 60 minutes of another transaction with the same name in a different city.

Each transaction string transactions[i] consists of comma separated values representing the name, time (in minutes), amount, and city of the transaction.

Given a list of transactions, return a list of transactions that are possibly invalid. You may return the answer in any order.

Example 1:

Input: transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
Output: ["alice,20,800,mtv","alice,50,100,beijing"]
Explanation: The first transaction is invalid because the second transaction occurs within a difference of 60 minutes, have the same name and is in a different city. Similarly the second one is invalid too.

Example 2:

Input: transactions = ["alice,20,800,mtv","alice,50,1200,mtv"]
Output: ["alice,50,1200,mtv"]

Example 3:

Input: transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]
Output: ["bob,50,1200,mtv"]

Constraints:

transactions.length <= 1000
Each transactions[i] takes the form "{name},{time},{amount},{city}"
Each {name} and {city} consist of lowercase English letters, and have lengths between 1 and 10.
Each {time} consist of digits, and represent an integer between 0 and 1000.
Each {amount} consist of digits, and represent an integer between 0 and 2000.

Solution:

class Solution {
    public List<String> invalidTransactions(String[] transactions) {
        Map<String, TreeMap<Integer, Set<String>>> map = new HashMap();
        Set<String> invalid = new HashSet();
        for (String txn : transactions) {
            String[] arr = txn.split(",");
            String name = arr[0];
            int time = Integer.parseInt(arr[1]);
            int amount = Integer.parseInt(arr[2]);
            String city = arr[3];
            map.computeIfAbsent(name, k -> new TreeMap());
            map.get(name).computeIfAbsent(time, k -> new HashSet());
            map.get(name).get(time).add(city);
        }
        List<String> result = new ArrayList();
        for (String txn : transactions) {
            String[] arr = txn.split(",");
            String name = arr[0];
            int time = Integer.parseInt(arr[1]);
            int amount = Integer.parseInt(arr[2]);
            String city = arr[3];
            if (amount > 1000) {
                result.add(txn);
            } else {
                TreeMap<Integer, Set<String>> txns = map.get(name);
                if ((txns.get(time).size() > 1)) {
                    result.add(txn);
                } else {
                    Map<Integer, Set<String>> sub = txns.subMap(time - 60, time + 60 + 1);
                    for (Map.Entry<Integer, Set<String>> entry : sub.entrySet()) {
                        Set<String> cities = entry.getValue();
                        if (cities.size() > 1 || !cities.contains(city)) {
                            result.add(txn);
                            break;
                        }
                    }
                }
            }
        }
        return result;
    }
}