转化为全零矩阵的最少反转次数

Posted 2023-05-27 929code

二进制矩阵，可以选择任意位置进行反转，其周围格子也会跟着反转
求使得矩阵全为0的最少反转次数

1. 广度优先搜索

将每个状态转化为字符串进行存储，方便剪枝和压缩

class Solution 
public:
    int m; int n;
    vector<vector<int>> dir = 0,0,1,0,0,1,0,-1,-1,0;
    int minFlips(vector<vector<int>>& mat) 
        m = mat.size(); n = mat[0].size();
        string str = vec_str(mat);
        set<string> s; //剪枝
        queue<string> q; //状态队列
        s.insert(str);
        q.push(str);
        int count = 0;
        while(!q.empty())//最小
            int len = q.size();
            for(int times=0;times<len;times++)
                string cur = q.front(); q.pop();
                if(check(cur)) return count;//满足条件直接返回操作次数
                for(int i=0;i<m;i++) //对所有位置进行翻转
                    for(int j=0;j<n;j++)
                        string next = transform(cur,i,j);
                        if(s.count(next)) continue;
                        q.push(next);
                        s.insert(next);
                          
            
            count++;
        
        return -1;
    


    bool check(string& s)
        for(int i=0;i<s.size();i++)
            if(s[i]==\'1\') return false;
        return true;
    

    string vec_str(vector<vector<int>>& mat)
        string res;
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                res.push_back(mat[i][j]+\'0\');
        return res;
    

    string transform(string s,int x,int y)
        for(int i=0;i<dir.size();i++)
            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            if(nx<0||nx==m||ny<0||ny==n) continue;
            s[nx*n+ny] = !(s[nx*n+ny]-\'0\')+\'0\';
        
        return s;
    
;

[M贪心] lc1888. 使二进制字符串字符交替的最少反转次数(贪心+前后缀分解+周赛244_3)

文章目录

• • 1. 题目来源
  • 2. 题目解析

1. 题目来源

链接：1888. 使二进制字符串字符交替的最少反转次数

2. 题目解析

贪心题。

很麻烦的一道题…没啥思路。

能知道从原串转化到 01 或 10 相间的串，与从 01 或 10 相间的串转化到原串，所用的类型 2 操作应该是一致的。

故，我们可以考虑如何将一个 01 相间的串转化为原串，其中类型1 操作可以任意使用，保证类型2 操作最少。

• 那么针对原串长度为偶数情况来讲，类型 1 操作不论做多少次，都只会构成 010101...01 或 101010...10 串这两种情况。最少的类型2 操作次数可以直接与原串进行比对，看这两种情况下相异位置的个数即可。
• 原串长度为奇数情况下，需要分 4 类情况。
  • 情况1：形如 010101...01
  • 情况2：形如 101010...10
  • 情况3：形如 010101...110101
  • 情况4：形如 101010...001010
  • 其中情况1、2 与偶数情况一直，可以直接与原串比较相异位置的个数即可。
  • 情况3、4 是在奇数长度情况下做类型 1 操作出现的特殊情况。 由于连续 00、11 会出现在 n 个位置，暴力枚举将达到 $O(n^2)$。
  • 考虑前后缀分解，以相等的两个 00、11 做分割，分割出前后两段，预处理前后两段的操作次数，用 $O(1)$ 的时间计算，枚举 $O(n)$ 次，总共时间复杂度为 $O(n)$。

---

详细，看手写笔记：

---

时间复杂度：$O(n)$

空间复杂度：$O(n)$

---

class Solution {
public:
    int minFlips(string s) {
        int n = s.size();
        vector<int> l[2], r[2];
        l[0] = l[1] = r[0] = r[1] = vector<int>(n);

        // 两种情况，01 开头，10 开头，预处理 l 数组的两种情况
        for (int i = 0; i < 2; i ++ )
            for (int j = 0, c = 0, k = i; j < n; j ++ , k ^= 1) {
                if (k != s[j] - '0') c ++ ;         // 相异字符则需要进行类型二操作
                l[i][j] = c;
            }
        
        // 两种情况，01 开头，10 开头，预处理 r 数组的两种情况
        for (int i = 0; i < 2; i ++ )
            for (int j = n - 1, c = 0, k = i; ~j; j -- , k ^= 1) {
                if (k != s[j] - '0') c ++ ;
                r[i][j] = c;
            }

        // 偶数情况，直接取类型 l 数组的两种情况即可
        if (n % 2 == 0) return min(l[0][n - 1], l[1][n - 1]);
        else {
            // 奇数情况，前两种情况取 l 数组的两种情况即可
            int res = min(l[0][n - 1], l[1][n - 1]);
            
            // 后两种相邻两个 1 ，相邻两个 0 的两种情况
            // 枚举相邻元素的第一个元素，其第二个元素不可越界
            for (int i = 0; i + 1 < n; i ++ ) {
                res = min(res, l[0][i] + r[1][i + 1]);      // 两个连续 1
                res = min(res, l[1][i] + r[0][i + 1]);      // 两个连续 0
            }
            return res;
        }
        // 最后结果不用 return 也可以...一定再之前 return 掉了
        return min(l[0][n - 1], l[1][n - 1]);
    }
};