LeetCode Weekly Contest

33： 链接：https://leetcode.com/contest/leetcode-weekly-contest-33/

A.Longest Harmonious Subsequence

思路：hash加查找

class Solution {
public:
    int findLHS(vector<int>& nums) {
        if (nums.empty())
            return 0;
            
        int res = 0;
        int len = nums.size();
        unordered_map<int, int> hash;
        for (int i = 0; i < len; i++)
            hash[nums[i]]++;
        for (auto it: hash)
        {
            if (hash.count(it.first + 1))
                res = max(res, it.second + hash[it.first + 1]);
        }
        
        return res;
    }
};

B.Valid Square

思路：怎么判断是正方形呢（输入四个点无序）

只要四边边长均相等然后两个对角线长为边长的根号2倍即可

（注意距离大于0不然就是同一个点了，WA了一次）

class Solution {
public:
    bool validSquare(vector<int>& p1, vector<int>& p2, vector<int>& p3, vector<int>& p4) {
        vector<long long> dis;
        long long d;
        d = (p2[1] - p1[1]) * (p2[1] - p1[1]) + (p2[0] - p1[0]) * (p2[0] - p1[0]);
        dis.push_back(d);
        d = (p3[1] - p1[1]) * (p3[1] - p1[1]) + (p3[0] - p1[0]) * (p3[0] - p1[0]);
        dis.push_back(d);
        d = (p2[1] - p4[1]) * (p2[1] - p4[1]) + (p2[0] - p4[0]) * (p2[0] - p4[0]);
        dis.push_back(d);
        d = (p4[1] - p3[1]) * (p4[1] - p3[1]) + (p4[0] - p3[0]) * (p4[0] - p3[0]);
        dis.push_back(d);
        d = (p4[1] - p1[1]) * (p4[1] - p1[1]) + (p4[0] - p1[0]) * (p4[0] - p1[0]);
        dis.push_back(d);
        d = (p2[1] - p3[1]) * (p2[1] - p3[1]) + (p2[0] - p3[0]) * (p2[0] - p3[0]);
        dis.push_back(d);
        sort(dis.begin(), dis.end());
        
        if (dis[0] && dis[0] == dis[1] && dis[1] == dis[2] && dis[2] == dis[3] && dis[4] == 2 * dis[3] && dis[5] == 2 * dis[3])
            return true;
        else
            return false;
    }
};

C.Fraction Addition and Subtraction

思路:分数加减法，先单独算出每个分数的值，用c/d表示，然后结果用a/b表示，注意正负号，初始化a = 0, b = 1

(注意c，d数字可能大于9，所以要用while进行判断，WA了一次，b初始化为1，因为0不能做分母，0与任何数的最大公约数就是这个数，最小公倍数 = x*y/最大公约数)

class Solution {
public:
    long long gcd(long long x, long long y)
    {
        return y == 0 ? x : gcd(y, x % y); 
    }
    string fractionAddition(string expression) {
        long long p, q;
        long long flag = 1;
        long long a = 0, b = 1, c = 0, d = 0;
        int len = expression.size();
        string res;

        for (int i = 0; i < len; i++)
        {
            if (expression[i] == '-')
            {
                    flag = -1;
            }
            else if (expression[i] == '+')
            {
                    flag = 1;
            }
            else if ( '0' <= expression[i] && expression[i] <= '9')
            {
                while ('0' <= expression[i] && expression[i] <= '9')
                    c = c * 10 + (expression[i++] - '0');
                c *= flag;
                i--;
            }
            else if (expression[i] == '/')
            {
                i++;
                while ('0' <= expression[i] && expression[i] <= '9')
                    d = d * 10 + (expression[i++] - '0');
                i--;

                q = gcd(b, d);
                p = b * d / q;
                a = a * d / q;
                c = c * b / q;
                
                a = a + c;
                q = gcd(abs(a), p);
                a = a / q;
                b = p / q;
                c = d = 0;
            }
            else
                ;
        }
        
        res += to_string(a) + "/" + to_string(b);
        
        return res;
    }
};

 （总结：思路比较清晰，就是写起来还得注意细节方面，WA了好几次，特例特判还是得多做题啊，加油！）

 

34: 链接：https://leetcode.com/contest/leetcode-weekly-contest-34/

1.Range Addition II

思路：直接算出最小的那个区间相乘就是结果

（注意判断为空的情况）

class Solution {
public:
    int maxCount(int m, int n, vector<vector<int>>& ops) {
        if (ops.empty())
            return m * n;
            
        int a, b;
        a = b = INT_MAX;
        for (int i = 0; i < ops.size(); i++)
        {
            a = min(a, ops[i][0]);
            b = min(b, ops[i][1]);
        }
        return a * b;
    }
};

下边这个写法比较巧妙：

class Solution {
public:
    int maxCount(int m, int n, vector<vector<int>>& ops) {
        for (auto op: ops)
        {
            m = min(m, op[0]);
            n = min(n, op[1]);
        }
        return m * n;
    }
};

2.Minimum Index Sum of Two Lists

思路：hash下第一个列表，然后再第二个列表中查找相同的字符串，并且计算下标的和，如果小，则清空数组压进去此时的字符串，如果相等则直接压入，如果大于不处理

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string, int> hash;
        vector<string> res;
        int sum, num = INT_MAX;
        
        if (list1.empty() || list2.empty())
            return res;
        
        for (int i = 0; i < list1.size(); i++)
            hash[list1[i]] = i;
        
        for (int j = 0; j < list2.size(); j++)
        {
            if (hash.count(list2[j]))
            {
                sum = hash[list2[j]] + j;
                if (num == INT_MAX)
                {
                    num = sum;
                    res.push_back(list2[j]);
                }
                else if (sum == num)
                    res.push_back(list2[j]);
                else if (sum < num)
                {
                    num = sum;
                    res.clear();
                    res.push_back(list2[j]);
                }
                else
                    ;
            }
        }
        return res;
    }
};

稍简洁版本：

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string, int> hash;
        vector<string> res;
        int sum;
        int num = INT_MAX;
        
        if (list1.empty() || list2.empty())
            return res;
        
        for (int i = 0; i < list1.size(); i++)
            hash[list1[i]] = i;
        
        for (int j = 0; j < list2.size(); j++)
        {
            if (hash.count(list2[j]))
            {
                sum = hash[list2[j]] + j;
                if (sum < num)
                {
                    num = sum;
                    res.clear();
                    res.push_back(list2[j]);
                }
                else if (sum == num)
                    res.push_back(list2[j]);
                else
                    ;
            }
        }
        return res;
    }
};

3.Array Nesting

思路：这个是hihocoder做过的一道题，直接每个进行判断，判断完了之后去找值对应的id

class Solution {
public:
    int arrayNesting(vector<int>& nums) {
        int n = nums.size();
        int count = 0;
        int res = 0;
        vector<int> vis;
        
        vis.resize(n, 0);
        int i = 0;
        while (i < n)
        {
            if (vis[i])
            {
                res = max(res, count);
                count = 0;
                i++;
            }
            else
            {
                vis[i] = 1;
                count++;
                i = nums[i];
            }
        }
        return res;
    }
};

4.Non-negative Integers without Consecutive Ones

思路：不连续的1，用dp描述就是：dp[i][0] = dp[i - 1][0] + dp[i - 1][1]; dp[i][1] = dp[i - 1][0];然后再处理每一位的数字即可

class Solution {
public:
    int dp[32][2];
    void init()
    {
        dp[0][0] = dp[0][1] = 1;
        for (int i = 1; i <= 31; i++)
        {
            dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
            dp[i][1] = dp[i - 1][0];
        }
    }
    int dfs(int len, int num)
    {
        if (len <= 0)
            return 1;
        
        int val = 1 << (len - 1);
        if (num >= val)
            return dp[len - 1][0] + dfs(len - 2, num - val);
        else
            return dfs(len - 1, num);
        
    }
    int findIntegers(int num) {
        init();
        int len = 0;
        int n = num;
        
        while (n)
        {
            len++;
            n >>= 1;
        }
        
        return dfs(len, num);
    }
};