• 红绿正方形染色问题


    红绿正方形染色问题

    作者:Grey

    原文地址:

    博客园:红绿正方形染色问题

    CSDN:红绿正方形染色问题

    题目描述

    有一些排成一行的正方形。每个正方形已经被染成红色或者绿色。现在可以选择任意一个正方形然后用这两种颜色的任意一种进行染色,这个正方形的颜色将会被覆盖。目标是在完成染色之后,每个红色 R 都比每个绿色 G 距离最左侧近。 返回最少需要涂染几个正方形,示例: s = RGRGR,我们涂染之后变成 RRRGG 满足要求了,涂染的个数为 2, 没有比这个更好的涂染方案。

    题目链接见:牛客:红和绿

    思路

    要满足染色后,每个红色 R 都比每个绿色 G 距离最左侧近,只有可能是下述三种情况:

    1. R 都在左边,G 都在右边;

    2. 全 G;

    3. 全 R。

    定义两个数组

    int[] leftG = new int[N];
    

    leftG[i]表示 i 位置的左边包括 i 在内有几个 G。

    通过从右往左遍历一次数组可以预处理得到leftG数组。

    int[] rightR = new int[N];
    

    rightR[i]表示 i 位置右边包括 i 在内有几个 R。

    通过从左往右遍历一次数组可以预处理得到rightR数组

    如果rightR[0] == N || leftG[N - 1] == N,说明数组全为 R 或者全为 G,此时无需染色,直接返回 0。

    如果是普遍情况,那就直接判断每个位置为分割点,左侧都变为 R,右侧都变为 G,需要的最小染色次数是多少,即:leftG[i] + rightR[i] - 1,之所以要减 1 是因为重复算了 i 位置的情况。

    完整代码见

    import java.util.Scanner;
    // R都在左边,G都在右边,或者全G,全R
    public class Main {
        
        // 两个预处理数组
        // TODO 空间方面可以优化
        public static int minColors(String str) {
            if (str == null || str.length() <= 1) {
                return 0;
            }
            char[] strs = str.toCharArray();
            int N = strs.length;
            // leftG[i]表示左边包括i在内有几个G
            int[] leftG = new int[N];
            // rightR[i]表示右边包括i在内有几个R
            int[] rightR = new int[N];
            for (int i = 0; i < N; i++) {
                if (strs[i] == 'G') {
                    if (i == 0) {
                        leftG[i]++;
                    } else {
                        leftG[i] = leftG[i - 1] + 1;
                    }
                } else {
                    if (i != 0) {
                        leftG[i] = leftG[i - 1];
                    }
                }
            }
            for (int i = N - 1; i >= 0; i--) {
                if (strs[i] == 'R') {
                    if (i == N - 1) {
                        rightR[i]++;
                    } else {
                        rightR[i] = rightR[i + 1] + 1;
                    }
                } else {
                    if (i != N - 1) {
                        rightR[i] = rightR[i + 1];
                    }
                }
            }
    
            // 全R或者全G的情况
            if (rightR[0] == N || leftG[N - 1] == N ) {
                return 0;
            }
    
            int min = N;
            for (int i = 0; i < N; i++) {
                // 之所以要-1是因为重复算了i位置的处理情况
                min = Math.min(leftG[i] + rightR[i] - 1, min);
            }
            return min;
        }
    
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            String colors = in.nextLine();
            System.out.println(minColors(colors));
            in.close();
        }
    }
    

    空间复杂度O(N),时间复杂度O(N)

    更多

    算法和数据结构笔记

  • 相关阅读:
    线性表的顺序存储结构详解
    Java就业急训营-感悟与分享
    在Ubuntu系统下用C语言编写程序
    NTIRE介绍和近年来超分SR结果展示
    《王道操作系统》学习笔记:计算机系统概述
    JavaScript 语言通识 — 重学 JavaScript
    python利用numpy存取文件
    Batch Normalization(批标准化,BN)
    全零填充(padding)
    感受野(Receptive Field)理解为什么采用多层小卷积核来替换一层大卷积核
  • 原文地址:https://www.cnblogs.com/greyzeng/p/16728462.html
Copyright © 2020-2023  润新知