LeetCode Weekly Contest 22

1. 532. K-diff Pairs in an Array

分析：由于要唯一，所以要去重，考虑k=0，时候，相同的数字需要个数大于1，所以，先用map统计个数，对于k=0，特判，对于其他的，遍历每一个数，只需要判断a + k是否存在即可。

这个题目，是absolute difference，我没注意这点，没有判断k<0,直接return 0，导致出错。

 class Solution {
 public:
 int findPairs(vector<int>& nums, int k) {
     if(k < ) return ;
     int n = nums.size();
     int res = ;
     map<int, int> ma;
     for (int x : nums) {
         ma[x]++;
     }
     if(k == ) {
         for (auto it : ma) {
             if(it.second > ) res++;
         }
         return res;
     }
     for (auto it : ma) {
         int x = it.first;
         if(ma.count(x + k)) res++;
     }
     return res;
 }
 };

2. 531. Lonely Pixel I

预处理出行列元素个数，然后扫描每一个元素进行处理，比较简单。

 class Solution {
 public:
 int findLonelyPixel(vector<vector<char>>& p) {
     int n = p.size();
     if(n == ) return ;
     int m = p[].size();
     if(m == ) return ;
     vector<int> row(n, ), col(m, );
     for (int i = ; i < n; i++) {
         for (int j = ; j < m; j++) {
             if(p[i][j] == 'B') {
                 row[i]++;
                 col[j]++;
             }
         }
     }
     int res = ;
     for (int i = ; i < n; i++) {
         for (int j = ; j < m; j++) {
             if(p[i][j] == 'B') {
                 if(row[i] ==  && col[j] == ) res++;
             }
         }
     }
     return res;
 }
 };

3. 533. Lonely Pixel II

也是要先预处理出每行，每列的b的个数，然后进行处理。

分析这个题目，是要按列进行考虑的，因为满足要求的b的列的位置上为b的这些行要相同，所以如果只要有一个不满足要求，这一列的b都是不满足要求的。

同时注意到，每2行可能需要比较多次，每次都是相同重复的，可以记录下来，进行加速处理。也算比较简单。

 class Solution {
 public:
  int findBlackPixel(vector<vector<char>>& p, int k) {
     int n = p.size();
     if(n == ) return ;
     int m = p[].size();
     if(m == ) return ;
     vector<int> row(n, ), col(m, );
     for (int i = ; i < n; i++) {
         for (int j = ; j < m; j++) {
             if(p[i][j] == 'B') {
                 row[i]++;
                 col[j]++;
             }
         }
     }
     int res = ;
     map<pair<int, int>, bool> ma;
     for (int j = ; j < m; j++) {
         if(col[j] != k) continue;
         int id = -;
         bool f = ;
         for (int i = ; i < n; i++) {
             if(p[i][j] == 'B') {
                 if(row[i] != k) {
                     f = ;break;
                 }
                 if(id == -) id = i;
                 else {
                     if(ma.count({id, i})) {
                         if(!ma[{id, i}]) {
                             f = ;
                             break;
                         }
                     }
                     for (int x = ; x < m; x++) {
                         if(p[id][x] != p[i][x]) {
                             ma[{id, i}] = ;
                             f = ;
                             break;
                         }
                     }
                     if(f) {
                         ma[{id, i}] = ;
                     } else
                     break;
                 }
             }
         }
         if(f) res += k;
     }
     return res;
 }
 };

4. 514. Freedom Trail

分析：读懂题意，这么多英文描述，我一看，脑袋都花了！

然后，我想着是不是贪心，每次都转移到最近的一个字母，但是提交以后，wa。然后观察例子，分析出是dp。

因为这一次的转移会影响下一次的转移，局部是最优的，但是不能保证全局最优，所以需要记录所有的状态，然后进行处理。

考虑合法的转移状态，注意非法的情况。还有，这题的数据范围很小，100,100的，如果是贪心，那也太小了，所以，一般是dp的可能性很大，最后dp的复杂度是100*100*100，可以在1s的实现内运行完毕。

 class Solution {
 public:
 int findRotateSteps(string ring, string key) {
     int n = ring.size();
     int m = key.size();
     if(n == ) {
         return m;
     }
     vector<vector<int>> dp(m + , vector<int>(n + , -));
     dp[][] = ;
     for (int i = ; i <= m; i++) {
         char cur = key[i - ];
         for (int j = ; j < n; j++) {
             if(dp[i - ][j] == -) continue;
             for (int x = ; x < n; x++) {
                 if(ring[x] == cur) {
                     int y = abs(x - j);
                     if(n - y < y) y = n - y;
                     if(dp[i][x] == -)
                         dp[i][x] = dp[i - ][j] + y;
                     else
                         dp[i][x] = min(dp[i][x], dp[i - ][j] + y);
                 }
                 //cout << j << " " << x << " " << i << " "<< dp[i][x] << endl;
             }
         }
     }
     int res = INT_MAX;
     for (int i = ; i < n; i++)
         if(dp[m][i] != -)
         res = min(res, dp[m][i]);
     return res + m;
 }
 };

要求最小值，dp非法值处理的-1的情况，代码写的比较复杂，应该处理成INT_MAX，这样非法情况可以像正常情况一样处理，但是要注意溢出哦，可以取一个很大的数，而不是INT_MAX就行了。

这次题目不是很难，但是我写的还是比较慢！还需要多练！