AtCoder Beginner Contest 264 F - Monochromatic Path DP

F - Monochromatic Path

大意

给定01矩阵,可以任意翻转一行或一列(即取反)花费为$R[i]$,$C[j]$，问只走单色格子只能向下向右走从$（1,1）$到$（n,m）$的最小花费

思路

只求解走白色格子的，对整个矩阵取反后再求一次走白格子的（在原矩阵中为只走黑格子）。具体实现和思路在代码注释中。

#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
const int N = 2010;
const ll inf = 1e18;
int n,m;
int a[N][N],R[N],C[N];
ll f[N][N][2][2];//在i,j位置翻转行/列/不翻
ll solve()//只求走白色格子0的最小花费
{
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=0;k<2;k++){
                for(int p=0;p<2;p++) f[i][j][k][p] = inf;
            }
        }
    }
    //每一行每一列最多被翻转一次,否则更多次则没有意义
    //初始化第一格
    if(a[1][1] == 0)
    {
        f[1][1][0][0] = 0;
        f[1][1][1][1] = R[1] + C[1];
    }
    else
    {
        f[1][1][1][0] = R[1];
        f[1][1][0][1] = C[1];
    }

    for(int i = 1;i <= n;i ++){
        for(int j = 1;j <= m;j ++){
            ll &v1 = f[i][j][0][0];
            ll &v2 = f[i][j][0][1];
            ll &v3 = f[i][j][1][0];
            ll &v4 = f[i][j][1][1];

            if(i > 1){
                if(a[i][j] == 0)//本身是白色，只可能不翻转，或者行列各翻转一次所以只枚举[0,0],[1,1]的状态
                {
                    v1 = min(v1 , f[i - 1][j][0][0]);//[i-1,j]也是白色 直接走来
                    v1 = min(v1 , f[i - 1][j][1][0]);//[i-1,j]原本是黑色,经过对行翻转后是白色也可以直接走来
                    v4 = min(v4 , f[i - 1][j][1][1] + R[i]);//[i-1,j]是白色，对行和列都进行了翻转，所以[i,j]也需要进行相同的翻转,但上一次翻转已经对列进行影响[0,1]所以此吃只需要翻转行就变成了[1,1]
                    v4 = min(v4 , f[i - 1][j][0][1] + R[i]);//[i-1,j]是黑色，经过队列的翻转变成白色，本格子同样对行翻转还是白色
                }
                else//本身是黑色必须对行或者列翻转一次
                {
                    v2 = min(v2 , f[i - 1][j][1][1]);//[i-1,j]是白色经过行列都翻转,对[i,j]的影响就是已经翻转一次，直接转移
                    v2 = min(v2 , f[i - 1][j][0][1]);//[i-1,j]是黑色对列进行翻转,影响到[i,j]也进行了一次翻转变成了白色,直接转移
                    v3 = min(v3 , f[i - 1][j][0][0] + R[i]);//[i-1,j]是白色且未进行翻转,s所以对[i,j]的行翻转一次即可
                    v3 = min(v3 , f[i - 1][j][1][0] + R[i]);//[i-1,j]是黑色对行进行翻转变成白色,所以[i,j]也需要对行进行翻转
                }
            }

            if(j > 1)
            {
                if(a[i][j] == 0)
                {
                    v1 = min(v1 , f[i][j - 1][0][0]);
                    v1 = min(v1 , f[i][j - 1][0][1]);//[i,j-1]原本是黑色,对列进行翻转变成白色直接转移
                    v4 = min(v4 , f[i][j - 1][1][1] + C[j]);
                    v4 = min(v4 , f[i][j - 1][1][0] + C[j]);
                }
                else
                {
                    v2 = min(v2 , f[i][j - 1][0][0] + C[j]);
                    v2 = min(v2 , f[i][j - 1][0][1] + C[j]);
                    v3 = min(v3 , f[i][j - 1][1][0]);
                    v3 = min(v3 , f[i][j - 1][1][1]);
                }
            }
        }
    }
    ll ans = inf;
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++) ans = min(ans , f[n][m][i][j]);
    }
    return ans;
}
int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++) cin >> R[i];
    for(int i=1;i<=m;i++) cin >> C[i];
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++) scanf("%1d",&a[i][j]);
    }
    
    ll ans = solve();//求走白色
    for(int i=1;i<=n;i++)//翻转后走白色相当于原矩阵只走黑色
        for(int j=1;j<=m;j++) a[i][j] ^= 1;
    
    ans = min(ans , solve());
    cout << ans << "\n";
    return 0;
}