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 ;

         int res = ;
         int len = nums.size();
         unordered_map<int, int> hash;
         for (int i = ; i < len; i++)
             hash[nums[i]]++;
         for (auto it: hash)
         {
             if (hash.count(it.first + ))
                 res = max(res, it.second + hash[it.first + ]);
         }

         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[] - p1[]) * (p2[] - p1[]) + (p2[] - p1[]) * (p2[] - p1[]);
         dis.push_back(d);
         d = (p3[] - p1[]) * (p3[] - p1[]) + (p3[] - p1[]) * (p3[] - p1[]);
         dis.push_back(d);
         d = (p2[] - p4[]) * (p2[] - p4[]) + (p2[] - p4[]) * (p2[] - p4[]);
         dis.push_back(d);
         d = (p4[] - p3[]) * (p4[] - p3[]) + (p4[] - p3[]) * (p4[] - p3[]);
         dis.push_back(d);
         d = (p4[] - p1[]) * (p4[] - p1[]) + (p4[] - p1[]) * (p4[] - p1[]);
         dis.push_back(d);
         d = (p2[] - p3[]) * (p2[] - p3[]) + (p2[] - p3[]) * (p2[] - p3[]);
         dis.push_back(d);
         sort(dis.begin(), dis.end());

         if (dis[] && dis[] == dis[] && dis[] == dis[] && dis[] == dis[] && dis[] ==  * dis[] && dis[] ==  * dis[])
             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 ==  ? x : gcd(y, x % y);
     }
     string fractionAddition(string expression) {
         long long p, q;
         long long flag = ;
         long long a = , b = , c = , d = ;
         int len = expression.size();
         string res;

         for (int i = ; i < len; i++)
         {
             if (expression[i] == '-')
             {
                     flag = -;
             }
             else if (expression[i] == '+')
             {
                     flag = ;
             }
             else if ( '' <= expression[i] && expression[i] <= '')
             {
                 while ('' <= expression[i] && expression[i] <= '')
                     c = c *  + (expression[i++] - '');
                 c *= flag;
                 i--;
             }
             else if (expression[i] == '/')
             {
                 i++;
                 while ('' <= expression[i] && expression[i] <= '')
                     d = d *  + (expression[i++] - '');
                 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 = ;
             }
             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 = ; i < ops.size(); i++)
         {
             a = min(a, ops[i][]);
             b = min(b, ops[i][]);
         }
         return a * b;
     }
 };

：

下边这个写法比较巧妙：

 class Solution {
 public:
     int maxCount(int m, int n, vector<vector<int>>& ops) {
         for (auto op: ops)
         {
             m = min(m, op[]);
             n = min(n, op[]);
         }
         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 = ; i < list1.size(); i++)
             hash[list1[i]] = i;

         for (int j = ; 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 = ; i < list1.size(); i++)
             hash[list1[i]] = i;

         for (int j = ; 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 = ;
         int res = ;
         vector<int> vis;

         vis.resize(n, );
         int i = ;
         while (i < n)
         {
             if (vis[i])
             {
                 res = max(res, count);
                 count = ;
                 i++;
             }
             else
             {
                 vis[i] = ;
                 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[][];
     void init()
     {
         dp[][] = dp[][] = ;
         for (int i = ; i <= ; i++)
         {
             dp[i][] = dp[i - ][] + dp[i - ][];
             dp[i][] = dp[i - ][];
         }
     }
     int dfs(int len, int num)
     {
         if (len <= )
             return ;

         int val =  << (len - );
         if (num >= val)
             return dp[len - ][] + dfs(len - , num - val);
         else
             return dfs(len - , num);

     }
     int findIntegers(int num) {
         init();
         int len = ;
         int n = num;

         while (n)
         {
             len++;
             n >>= ;
         }

         return dfs(len, num);
     }
 };

：