Leetcode 1169. Query invalid transactions (if the amount of data is small, this problem still needs to be solved by violent enumeration)

If the following two situations occur , transaction May not be valid ：

• Transaction amount exceeds $1000
• perhaps , It and Another city in The same name The other transaction is no more than 60 minute （ contain 60 Minutes ）

Given string array transaction list transaction . Each transaction string transactions[i] Consists of values separated by commas , These values represent the name of the transaction , Time （ In minutes ）, Amount and city .

return transactions, Returns a list of transactions that may not be valid . You can press In any order Return to the answer .

Example 1：

 Input ：transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
 Output ：["alice,20,800,mtv","alice,50,100,beijing"]
 explain ： The first deal is void , Because the second transaction is not more than  60  minute 、 The names are the same and take place in different cities . Again , The second deal is also void .

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"]
 

Tips ：

• transactions.length <= 1000
• Every deal transactions[i] Press “{name},{time},{amount},{city}” The format for recording
• Name of each transaction {name} And the city {city} It's all made up of lowercase letters , The length is in 1 To 10 Between
• Every trading time {time} It's made up of some numbers , It means a 0 To 1000 Integer between
• The amount of each transaction {amount} It's made up of some numbers , It means a 0 To 2000 Integer between

Main idea ：

1. First split the string
2. Then enumerate directly according to the requirements

Code:

class Solution {
    
public:
    void str_split(const std::string & src, const std::string & sep, std::vector<string> & vec_str)
    {
    
        std::string::size_type start = 0;
        int i=0;
        for(std::string::size_type end = src.find(sep, start); end != std::string::npos; end = src.find(sep, start))
        {
    
            if(end > start)
            {
    
                
                string str=src.substr(start, end - start);
                vec_str.push_back(str);
            }
            start = end + sep.length();
        }
        if(start < src.length())
        {
    
            
            string str=src.substr(start, src.length() - start);
            vec_str.push_back(str);
            
        }
    }
    vector<string> invalidTransactions(vector<string>& transactions) {
    
        vector<string>res;
        vector<vector<string>>vec;
        for(int i=0;i<transactions.size();i++)
        {
    
            vector<string>temp;
            str_split(transactions[i],",",temp);
            vec.push_back(temp);
        }
        
        map<string,int>mymap;
        for(int i=0;i<vec.size();i++)
        {
    
            vector<string>sub=vec[i];
            if(atoi(sub[2].c_str())>1000)
            {
    
                string str=sub[0]+","+sub[1]+","+sub[2]+","+sub[3];
                // res.push_back(str);
                mymap.insert(pair<string,int>(str,0));
            }
            else
            {
    
                for(int j=0;j<vec.size();j++)
                {
    
                    if(j==i)
                        continue;
                    vector<string>sub2=vec[j];
                    if(sub2[3]!=sub[3])
                    {
    
                        if(sub2[0]==sub[0])
                        {
    
                            if(abs(atoi(sub[1].c_str())-atoi(sub2[1].c_str()))<=60)
                            {
    
                                string str=sub2[0]+","+sub2[1]+","+sub2[2]+","+sub2[3];
                                
                                string str2=sub[0]+","+sub[1]+","+sub[2]+","+sub[3];
                                mymap.insert(pair<string,int>(str,0));
                                mymap.insert(pair<string,int>(str2,0));
                                
                            }
                        }
                    }
                }
            }
        }
        
        map<string,int>::iterator it;
        
        for(it=mymap.begin();it!=mymap.end();++it)
        {
    
            int cnt=count(transactions.begin(),transactions.end(),it->first);
            for(int j=0;j<cnt;j++)
                res.push_back(it->first);
        }
        return res;
        
    }
};