【CF662C】Binary Table

题目

好吧,我连板子都不会了

有一个非常显然的做法就是\(O(2^nm)\)做法就是枚举每一行的状态,之后我们贪心去看看每一列是否需要翻转就好啦

显然这个做法非常垃圾过不去

首先我们发现每一列都不超过\(20\),考虑把每一列都压成一个状态

我们考虑设一些奇怪的东西

设\(g_i\)表示行的翻转状态为\(i\)的最优解,\(f_i\)表示有多少列的状态为\(i\),\(dp_i\)表示\(i\)这个状态最少有多少个\(1\)

显然\(dp_i=min\{bit(i),n-bit(i)\}\)

我们考虑有一列原来的状态是\(k\),行的翻转状态为\(i\),翻转之后这一列的状态是\(j\)

就会存在\(i\bigoplus k=j\),也就是\(i=j\bigoplus k\)

也就是说

\[g_i=\sum_{j\bigoplus k=i}f_k\times dp_j\]

发现这是一个异或卷积,于是我们\(fwt\)一下就好了

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#define re register
#define LL long long
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
const int maxn=(1<<20)+6;
LL cnt[maxn],dp[maxn],f[maxn];
int n,m,len;
char S[21][100005];
inline int Fwt(LL *t,int o) {
    for(re int i=2;i<=len;i<<=1)
        for(re int ln=i>>1,l=0;l<len;l+=i)
            for(re int x=l;x<l+ln;++x) {
                LL g=t[x],h=t[x+ln];
                t[x]=g+h,t[ln+x]=g-h;
                if(o) t[x]/=2ll,t[x+ln]/=2ll;
            }
}
int main() {
    scanf("%d%d",&n,&m);len=(1<<n);
    for(re int i=0;i<len;i++) cnt[i]=cnt[i>>1]+(i&1);
    for(re int i=0;i<len;i++) dp[i]=min(cnt[i],cnt[(len-1)^i]);
    for(re int i=1;i<=n;i++) scanf("%s",S[i]+1);
    for(re int i=1;i<=m;i++) {
        int now=0;
        for(re int j=1;j<=n;j++) {
            if(S[j][i]=='1') now|=1;
            now<<=1;
        }
        f[now>>1]++;
    }
    Fwt(f,0),Fwt(dp,0);
    for(re int i=0;i<len;i++) f[i]*=dp[i];
    Fwt(f,1);LL ans=f[0];
    for(re int i=1;i<len;i++) ans=min(ans,f[i]);
    std::cout<<ans;
    return 0;
}

原文地址:https://www.cnblogs.com/asuldb/p/10690196.html

时间: 2024-11-06 07:34:27

【CF662C】Binary Table的相关文章

【CF662C】Binary Table 按位处理

[CF662C]Binary Table 题意:给你一个$n\times m$的01网格,你可以进行任意次操作,每次操作是将一行或一列的数都取反,问你最多可以得到多少个1? $n\le 20,m\le 10^5$ 题解:我也不知道叫啥了,说状压也不对,说fwt也不太对,就叫按位处理得了. 显然有$O(2^nm)$暴力,先枚举每行是否取反,然后枚举每列,如果0多就取反,否则不取. 但我们发现我们完全可以将本质相同的列一起处理,什么叫本质相同的列呢?假如我们对每行是否取反的状态为S,则所有$xor

【CF662C】Binary Table(FWT)

[CF662C]Binary Table(FWT) 题面 洛谷 CF 翻译: 有一个\(n*m\)的表格(\(n<=20,m<=10^5\)), 每个表格里面有一个\(0/1\), 每次可以将一行或者一列的\(01\)全部翻转 回答表格中最少有多少个\(1\) 题解 发现\(n\)很小,\(m\)很大 状压是跑不掉了 如果我们确定翻转哪些行,那么答案唯一确定(贪心的选每一列中\(0/1\)的较小值) 相同的列显然可以合并, 把每一列按照\(01\)状压,记\(a[i]\)为状态为\(i\)的列

【Leetcode】Binary Tree Postorder Traversal

Given a binary tree, return the postorder traversal of its nodes' values. For example: Given binary tree {1,#,2,3}, 1 2 / 3 return [3,2,1]. Note: Recursive solution is trivial, could you do it iteratively? 思路:后序遍历比起先序遍历以及中序遍历要稍微复杂一点,可以考虑用两个stack进行操作,

【总结】alter table *** add constraint *** 用法

1. 主键约束 要对一个列加主键约束的话,这列就必须要满足的条件就是非空.因为主键约束:就是对一个列进行了约束,约束为(非空.不重复). [格式]alter table 表格名称 add constraint 约束名称 增加的约束类型 (列名) 例子:要对一个列加主键,列名为id,表名为emp alter table emp add constraint ppp primary key (id) 2. check约束就是给一列的数据进行了限制 [格式]alter table 表名称 add co

【Leetcode】Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level). For example: Given binary tree {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 return its level order traversal as: [ [3], [9,20], [15,7] ] 思路:使用

【Leetcode】Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root). For example: Given binary tree {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 return its bottom-up level order trave

【分享】w32service table XPsp2

Ord   Address   fnAddr   Symbols-------------------------------- [  0] BF999280: BF93569A (win32k!NtGdiAbortDoc (bf93569a))[  1] BF999284: BF94724B (win32k!NtGdiAbortPath (bf94724b))[  2] BF999288: BF87A90C (win32k!NtGdiAddFontResourceW (bf87a90c))[ 

「CF662C」 Binary Table

「CF662C」 Binary Table 题目链接 题目所给的 \(n\) 很小,于是我们可以考虑这样一种朴素做法:暴力枚举第 \(i\) 行是否翻转,这样每一行的状态就确定了,这时取每一列 \(0/1\) 个数较小的数字即可(因为每一列也可以翻转).这样的时间复杂度是 \(O(m\cdot2^n)\). 但是显然这样过不了. 我们发现表格的具体行列对我们的答案是没有影响的.即我们只需要知道状态为 \(x\) 的行或者状态为 \(x\) 的列的个数即可.由于 \(n\le20\),这启发我们对

【LeetCode】Binary Tree Right Side View 解题报告

[题目] Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom. For example: Given the following binary tree, 1 <--- / 2 3 <--- \ 5 4 <--- You should return [1, 3