小红的矩阵染色

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 矩阵行数
        int m = sc.nextInt();  // 矩阵列数
        int k = sc.nextInt();  // 最多可染色的格子数
        char[][] matrix = new char[n][m];

        // 读取矩阵数据
        for (int i = 0; i < n; i++) {
            matrix[i] = sc.next().toCharArray();
        }

        List<Integer> blockLengths = new ArrayList<>();

        // 按列遍历，找出所有垂直连续的白色块（长度≥2）
        for (int j = 0; j < m; j++) {  // 遍历每一列
            int currentBlockLength = 0;  // 当前连续白色块的长度
            for (int i = 0; i < n; i++) {  // 遍历列中的每一行
                if (matrix[i][j] == 'o') {  // 遇到白色格子，增加块长度
                    currentBlockLength++;
                } else {  // 遇到非白色格子（黑色）
                    // 若当前块长度≥2，记录下来（只有≥2的块才能产生得分）
                    if (currentBlockLength >= 2) {
                        blockLengths.add(currentBlockLength);
                    }
                    currentBlockLength = 0;  // 重置块长度
                }
            }
            // 处理列末尾可能存在的连续白色块
            if (currentBlockLength >= 2) {
                blockLengths.add(currentBlockLength);
            }
        }

        // 按块长度从大到小排序（优先处理长块，能产生更多得分）
        Collections.sort(blockLengths, Collections.reverseOrder());

        int score = 0;
        // 遍历所有块，计算最大得分
        for (int length : blockLengths) {
            if (k == 0) break;  // 染色次数用尽，退出

            // 取当前块长度与剩余染色次数的较小值（最多染这么多格子）
            int cellsToDye = Math.min(k, length);

            // 只有染色数≥2时才能产生得分（连续2个格子产生1分，3个产生2分，以此类推）
            if (cellsToDye >= 2) {
                score += cellsToDye - 1;
            }

            k -= cellsToDye;  // 消耗染色次数
        }

        System.out.println(score);
    }
}

n, m, k = map(int, input().split())
array = [[x for x in input()] for _ in range(n)]
arr = [] # 记录每个连续空白可得分数 for col in range(m):
    coun = -1  for row in range(n): # 遇到黑色格子，存储分数，并重置  if array[row][col] == '*': if coun >= 0: # 避免连续黑色格子添加-1的情况  arr.append(coun)
            coun = -1  else:
            coun += 1  # 列尾时添加该分数到arr  if coun >= 0:
        arr.append(coun)
arr.sort(reverse=True)
score = 0 for i in range(len(arr)): if arr[i]+1 < k:
        score += arr[i]
        k -= (arr[i]+1) else:
        score += (k-1)
        k = 0  break print(score)

#include <iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n, m, k, score = 0;
    cin >> n >> m >> k;
    vector<string> vec(n);
    for (int i = 0; i < n; i++)
        cin >> vec[i];
    vector<int> white;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (white.empty())
                white.push_back(0);
            if (vec[j][i] == '*') {
                if (white.back() < 2)
                    white.pop_back();
                white.push_back(0);
                continue;
            }
            white.back()++;
        }
        if (!white.empty()&&white.back() < 2)
            white.pop_back();
        white.push_back(0);
    }
    white.pop_back();
    sort(white.begin(), white.end(), [](auto const & a, auto const & b) {
        return a > b;
    });
    for (int num : white) {
        if (num >= k){
            score += k - 1;
            break;
            }
        else {
            k -= num;
            score += num - 1;
        }
    }
    cout << score;
}