Java 网格着色游戏：找到绘制的红蓝线的数目

问题描述：Walter有一个N*M大小的网格，最初每个单元格都是白色的。Walter可以画一个水平或垂直的笔划，可以是一个或多个单元格长。沃尔特只画红色的水平笔划和蓝色的垂直笔划沃尔特从不画两个水平或两个垂直笔划重叠。如果水平笔划与垂直笔划交叉，则单元格的颜色为绿色。给定具有单元格颜色模式的字符串，找出实现该字符串所需的红色和蓝色笔划数

---

输入：{“GRG”、“BGW”、“WWW”}操作：2个红色和3个蓝色笔划

我看不出动态编程会给这增加什么

使红色或绿色像素的每一连续行成为水平笔划

使蓝色或绿色像素的每个连续列成为垂直笔划

---

计算笔划总数。这再现了初始模式，并且是所需的最小笔划数：每个笔划尽可能延伸，而不与数据冲突。

我看不出动态编程会给这一点增加什么

import java.util.*;

public class GridColouring {

    public static int getStrokes(String [] grid) {
        int N = grid.length;
        int M = grid[0].length();
        HashSet<Integer> hr = new HashSet<>();
        HashSet<Integer> v = new HashSet<>();
        int count = 0;
        for (int i = 0; i < N; i++) {
            String row = grid[i];
            row = row.toUpperCase();
            for (int j = 0; j < M; j++) {
                // Precedence of 'and' greater than 'or'
                if (row.charAt(j) == 'G' || (row.charAt(j) == 'R' && !hr.contains(i))) {
                    hr.add(i);

                } else if (hr.contains(i)) {
                    if (j > 0 && grid[i].charAt(j - 1) == 'B') {
                        count++;
                    }
                }
                if (row.charAt(j) == 'G' || (row.charAt(j) == 'B' && !v.contains(j))) {
                    v.add(j);
                } else if(v.contains(j)) {

                    if (i > 0 && grid[i-1].charAt(j) == 'R') {
                        count++;
                    }
                }
            }
        }
        int horStrokes = hr.size();
        int verStrokes = v.size();

        int minStrokes = horStrokes + verStrokes + count;
        return minStrokes;
    }
    public static void main(String [] args) {

        String [] a = {"GR.","BG.","RBR","BBB"};
        System.out.println(getStrokes(a));
    }
}

使红色或绿色像素的每一连续行成为水平笔划

使蓝色或绿色像素的每个连续列成为垂直笔划

计算笔划总数。这再现了初始模式，是所需的最小笔划数：每个笔划尽可能延伸，而不会与数据冲突。

import java.util.*；
import java.util.*;

public class GridColouring {

    public static int getStrokes(String [] grid) {
        int N = grid.length;
        int M = grid[0].length();
        HashSet<Integer> hr = new HashSet<>();
        HashSet<Integer> v = new HashSet<>();
        int count = 0;
        for (int i = 0; i < N; i++) {
            String row = grid[i];
            row = row.toUpperCase();
            for (int j = 0; j < M; j++) {
                // Precedence of 'and' greater than 'or'
                if (row.charAt(j) == 'G' || (row.charAt(j) == 'R' && !hr.contains(i))) {
                    hr.add(i);

                } else if (hr.contains(i)) {
                    if (j > 0 && grid[i].charAt(j - 1) == 'B') {
                        count++;
                    }
                }
                if (row.charAt(j) == 'G' || (row.charAt(j) == 'B' && !v.contains(j))) {
                    v.add(j);
                } else if(v.contains(j)) {

                    if (i > 0 && grid[i-1].charAt(j) == 'R') {
                        count++;
                    }
                }
            }
        }
        int horStrokes = hr.size();
        int verStrokes = v.size();

        int minStrokes = horStrokes + verStrokes + count;
        return minStrokes;
    }
    public static void main(String [] args) {

        String [] a = {"GR.","BG.","RBR","BBB"};
        System.out.println(getStrokes(a));
    }
}

公共类网格着色{
公共静态int getStrokes（字符串[]网格）{
int N=网格长度；
int M=网格[0]。长度（）；
HashSet hr=新的HashSet（）；
HashSet v=新的HashSet（）；
整数计数=0；
对于（int i=0；i0&&grid[i].charAt（j-1）='B'）{
计数++；
}
}
如果（行字符（j）='G'| |（行字符（j）='B'&&&！v.contains（j）））{
v、 加（j）；
}否则，如果（v.包含（j））{
如果（i>0&&grid[i-1].charAt（j）='R'）{
计数++；
}
}
}
}
int horstropes=hr.size（）；
int-verStrokes=v.size（）；
int minStrokes=horstrookes+versstrokes+count；
回击；
}
公共静态void main（字符串[]args）{
字符串[]a={“GR.”、“BG.”、“RBR”、“BBB”}；
System.out.println（getStrokes（a））；
}
}

输出：8

导入java.util.*；
公共类网格着色{
公共静态int getStrokes（字符串[]网格）{
int N=网格长度；
int M=网格[0]。长度（）；
HashSet hr=新的HashSet（）；
HashSet v=新的HashSet（）；
整数计数=0；
对于（int i=0；i0&&grid[i].charAt（j-1）='B'）{
计数++；
}
}
如果（行字符（j）='G'| |（行字符（j）='B'&&&！v.contains（j）））{
v、 加（j）；
}否则，如果（v.包含（j））{
如果（i>0&&grid[i-1].charAt（j）='R'）{
计数++；
}
}
}
}
int horstropes=hr.size（）；
int-verStrokes=v.size（）；
int minStrokes=horstrookes+versstrokes+count；
回击；
}
公共静态void main（字符串[]args）{
字符串[]a={“GR.”、“BG.”、“RBR”、“BBB”}；
System.out.println（getStrokes（a））；
}
}

产出：8