模拟

这道题的主要考察点是模拟和最小化差异值的问题。具体来说，我们需要调整输入数组中的每一个数，使得它们的平均数最接近128，同时限定每个元素的值在 [0, 255] 范围内。代码的核心思想是对每个调整范围（-255<=i<=255）进行尝试，计算调整后的数组的平均值，并找到使得调整后平均值最接近128的那个i，相等则取i最小的那个即可

代码如下

cpp

#include <bits/stdc++.h>
using namespace std;

int pixelValues[105]; // 存储图像的像素点值
int totalPixels; // 图像的像素点总数
double minDifference; // 用于存储最小的差值
int optimalK; // 用于存储最优的K值

// 函数用于确保像素点值在0到255之间
int clampValue(int value) {
    if(value < 0) return 0;
    if(value > 255) return 255;
    return value;
}

signed main() {
    // 输入像素点值，直到没有新的输入
    while(cin >> pixelValues[++totalPixels]) {}
    totalPixels--; // 由于最后一次输入增加了 totalPixels，减去1恢复实际像素数量
    
    minDifference = 2000; // 初始设定一个较大的差值

    // 遍历所有可能的K值，从-255到255
    for(int k = -255; k <= 255; k++) {
        double sumNewImage = 0; // 存储调整后的像素总和
        
        // 对所有像素点进行调整，计算调整后的总和
        for(int i = 1; i <= totalPixels; i++) {
            sumNewImage += clampValue(pixelValues[i] + k); // 调整后的像素点并裁剪到0-255范围
        }
        
        // 计算调整后的图像平均值
        sumNewImage /= totalPixels;
        
        // 计算调整后的平均值与128的差值
        double currentDifference = abs(128.0 - sumNewImage);
        
        // 如果当前差值更小，或者相同但k值更小，则更新最优k
        if(currentDifference < minDifference) {
            minDifference = currentDifference;
            optimalK = k;
        }
    }
    
    // 输出最优的K值
    cout << optimalK << '\n';
    return 0;
}

python

def clamp_value(value):
    if value < 0:
        return 0
    if value > 255:
        return 255
    return value

pixel_values = list(map(int, input().split()))
total_pixels = len(pixel_values)

min_difference = float('inf')
optimal_k = 0

for k in range(-255, 256):
    adjusted_sum = 0
    for value in pixel_values:
        adjusted_sum += clamp_value(value + k)
    
    adjusted_average = adjusted_sum / total_pixels
    difference = abs(128 - adjusted_average)
    
    if difference < min_difference:
        min_difference = difference
        optimal_k = k

print(optimal_k)

java

import java.util.Scanner;
import java.util.Arrays;

public class Main {

    // 确保像素点值在 0 到 255 之间
    public static int clampValue(int value) {
        if (value < 0) return 0;
        if (value > 255) return 255;
        return value;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取像素点
        String[] input = scanner.nextLine().split(" ");
        int totalPixels = input.length;
        int[] pixelValues = new int[totalPixels];

        for (int i = 0; i < totalPixels; i++) {
            pixelValues[i] = Integer.parseInt(input[i]);
        }

        double minDifference = Double.MAX_VALUE;
        int optimalK = 0;

        // 遍历所有可能的k值
        for (int k = -255; k <= 255; k++) {
            double adjustedSum = 0;

            // 计算调整后的总和
            for (int i = 0; i < totalPixels; i++) {
                adjustedSum += clampValue(pixelValues[i] + k);
            }

            // 计算调整后的平均值
            double adjustedAverage = adjustedSum / totalPixels;

            // 计算当前差值
            double difference = Math.abs(128.0 - adjustedAverage);

            // 找到最优的k值
            if (difference < minDifference) {
                minDifference = difference;
                optimalK = k;
            }
        }

        // 输出最优的k值
        System.out.println(optimalK);
    }
}

题目内容

一个图像有$n$个像素点，存储在一个长度为$n$的数组$img$里，每个像素点的取值范围$[0,255]$的正整数。

请你给图像每个像素点值加上一个整数$k$（可以是负数），得到新图$newImg$，使得新图$newImg$的所有像素平均值最接近中位值$128$。

请输出这个整数$k$。

输入描述

$n$个整数，中间用空格分开

输出描述

一个整数$k$

备注

• $1 <= n <= 100$
• 如有多个整数$k$都满足，输出小的那个$k$；
• 新图的像素值会自动截取到$[0,255]$范围。当新像素值$<0$，其值会更改为$0$；当新像素值$>255$，其值会更改为$255$

例如$newImg=”-1 -2 256″$,会自动更改为$”0 0 255″$

样例1

输入

0 0 0 0

输出

128

说明

四个像素值都为$0$

样例2

输入

129 130 129 130

输出

-2

说明

$-1$的均值$128.5$，$-2$的均值为$127.5$，输出较小的数$-2$