2017-3-5 leetcode 442 531 533

今天莫名其妙睡到了中午，很难受。。。

leetcode442 https://leetcode.com/problems/find-all-duplicates-in-an-array/?tab=Description
leetcode531 https://leetcode.com/problems/lonely-pixel-i/?tab=Description
leetcode533 https://leetcode.com/problems/lonely-pixel-ii/?tab=Description

============================================================

442说的是
给你n个数，1 ≤ a[i] ≤ n，数组中每个数字保证只出现一次或者两次，要求输出所有出现两次的数字，空间复杂度O(0)，时间复杂度O(n)

我的思路
额。。。。因为出现的最大的数字是n，我们用每个元素的（n+1）的倍数来标记出现的次数好了。。。具体看程序

 class Solution {
 public:
     vector<int> findDuplicates(vector<int>& nums) {
         int n=nums.size();
         for(int i=;i<n;i++){
             int temp=nums[i]%(n+);
             nums[temp-]+=(n+);
         }
         vector<int> aim;
         for(int i=;i<n;i++){
             int temp=nums[i]/(n+);
             if(temp==)aim.push_back(i+);
         }
         return aim;
     }
 };

%

但是不太好啊，一方面是可能爆上限（但是因为给的是数组，1e9其实也不太可能），另一方面是大量的使用了除法和取余，效率很低啊....
关于取负数的方法我想过，但是我认为如果出现两次，负负得正，无法和没有出现过的数字区分开，当我看了讨论版的时候我傻了。。。。谁说非要离线检查状态了，可以在线嘛，如果发现想要把一个已经是负数的数取负，直接加到答案里就是了。。。

 public class Solution {
     // when find a number i, flip the number at position i-1 to negative.
     // if the number at position i-1 is already negative, i is the number that occurs twice.

     public List<Integer> findDuplicates(int[] nums) {
         List<Integer> res = new ArrayList<>();
         for (int i = 0; i < nums.length; ++i) {
             int index = Math.abs(nums[i])-1;
             if (nums[index] < 0)
                 res.add(Math.abs(index+1));
             nums[index] = -nums[index];
         }
         return res;
     }
 }

negative

然后又看到了一个骨骼惊奇的解法，因为n个数字，每个数字又保证不大于n，那么下标和数字可以对应起来，把他们放回原处，然后扫一遍，虽然感觉复杂度不是O(n)，而且正确性没有证明，不过思路倒是很独特。。

 class Solution {
 public:
     vector<int> findDuplicates(vector<int>& nums) {
         vector<int> res;
         int i = ;
         while (i < nums.size()) {
             if (nums[i] != nums[nums[i]-]) swap(nums[i], nums[nums[i]-]);
             else i++;
         }
         for (i = ; i < nums.size(); i++) {
             if (nums[i] != i + ) res.push_back(nums[i]);
         }
         return res;
     }
 };

swap

=============================================================、

531说的是
给你一个二维字符数组，里面有‘W’和‘B’，问你有多少个‘B’，他的同行同列没有其他的‘B’

我的思路
这题目没什么难的，开两个数组，扫一遍记录每行每列有几个B，只有一个的话就记录坐标，多个就是-2，没有是-1，复杂度是O(n*m)，空间是O(n+m)

 class Solution {
 public:
     int findLonelyPixel(vector<vector<char> >& picture) {
         int n=picture.size(),m=picture[].size();
         vector<int> cul,row;
         for(int i=;i<m;i++){
             cul.push_back(-);
         }
         for(int i=;i<n;i++){
             row.push_back(-);
         }
         for(int i=;i<n;i++){
             for(int j=;j<m;j++){
                 if(picture[i][j]=='B'){
                     if(row[i]==-){
                         row[i]=j;
                     }else row[i]=-;
                     if(cul[j]==-){
                         cul[j]=i;
                     }else cul[j]=-;
                 }
             }
         }
         int ans=;
         for(int i=;i<n;i++)
             if(row[i]>-)
                 if(cul[row[i]]==i)
                     ans++;
         return ans;
     }
 };

531

142ms超过了100%的用户hhhhhh

================================================================

533讲的是
给你一个二维字符数组，由‘W’和‘B’组成，请问有多少个B满足以下两个条件，
1，B所在的那一行那一列所拥有的B的数目都恰好为N
2，B所在的那一列的其他在该列也为B的行，他们要完全相同

我的思路
这题比较蛋疼，不太好理解，虽然可以按照他说的来模拟，但是复杂度是O((nm)^2)的（nm的枚举每一个点，然后nm的判断），不优雅。
可以发现，符合条件的B我们称为目标B，目标B所在的列一定只有N个B，我们称有N个B的列为目标列，每次某一目标列如果有一个B是目标B的话，那整列的B都是目标B，如果某一个目标列没有目标B，那么它里面B所在的行也被“污染”，被污染行有B的话，那么那一列一定不含目标B，被污染的行我们就不再check，这样保证每一行最多被检查两次（因为懒得把代码写漂亮，事实上写得足够好的话，可以保证每行只被检查（遍历）一次）

 class Solution {
 public:
     int findBlackPixel(vector<vector<char> >& picture, int N) {
         if(N==)return ;
         int n=picture.size(),m=picture[].size();
         if(!n||!m)return ;
         vector<int> col,row,cfl;//cfc means column first location
         vector<bool> rbo,cbo;//row_bool  column_bool
         for(int i=;i<m;i++){
             col.push_back();
             cfl.push_back(-);
             cbo.push_back();
         }
         for(int i=;i<n;i++){
             row.push_back();
             rbo.push_back();
         }
         for(int i=;i<n;i++){
             for(int j=;j<m;j++){
                 if(picture[i][j]=='B'){
                     row[i]++;
                     col[j]++;
                     if(picture[i][j]=='B'){
                         if(cfl[j]==-)cfl[j]=i;
                     }
                 }
             }
         }
         int ans=;
         //ini
         for(int i=;i<n;i++){
             if(row[i]!=N){
                 for(int j=;j<m;j++){
                     if(picture[i][j]=='B'){
                         cbo[j]=;
                     }
                 }
             }
         }
         for(int j=;j<m;j++){
             if(col[j]==N&&cbo[j]){
                 if(N==){
                     if(row[cfl[j]]==)ans++;
                     continue;
                 }
                 int flag=;//check pass
                 int tot=;//how many aim column this check contain
                 for(int i=cfl[j]+;i<n&&flag;i++){
                     if(picture[i][j]=='B'){
                         for(int k=;k<m&&flag;k++){
                             if(picture[i][k]=='B'&&col[k]==N)tot++;
                             if(picture[i][k]!=picture[cfl[j]][k]){
                                 flag=;
                             }
                         }
                     }
                 }
                 tot/=(N-);
                 tot*=N;
                 if(flag){
                     ans+=tot;
                     for(int k=;k<m;k++){
                         if(picture[cfl[j]][k]=='B'&&col[k]==N)
                             cbo[k]=;
                     }
                 }else{
                     for(int i=cfl[j];i<n;i++){
                         if(picture[i][j]=='B'){
                             for(int k=;k<m;k++){
                                 if(picture[i][k]=='B')
                                     cbo[k]=;
                             }
                         }
                     }
                 }
             }
         }
         return ans;
     }
 };

533

一道坑爹模拟题。。。

看到一些写的比我短的，都用了map,set，大致看了看就是优化了字符串比较那块，，，本质是一样的。