华为OD机考算法题：相同数字的积木游戏1

题目部分

题目	相同数字的积木游戏1
难度	易
题目说明	小华和小薇一起通过玩积木游戏学习数学。 他们有很多积木，每个积木块上都有一个数字，积木块上的数字可能相同。 小华随机拿一些积木挨着排成一排，请小薇找到这排积木中数宇相同且所处位置最远的 2 块积木块，计算他们的距离。 小薇请你帮忙替解决这个问题。
输入描述	​​​第一行输入为 N，表示小华排成一排的积木总数。 接下来 N 行每行一个数字，表示小华排成一排的积木上数字。
输出描述	相同数字的积木的位置最远距离； 如果所有积木数字都不相同，请返回。
补充说明	无
------------------------------------------------------
示例
示例1
输入	5 1 2 3 1 4
输出	3
说明	说明一共有 5 个积木，第 1 个积木和第 4 个积木数字相同，其距离为 3。
示例2
输入	2 1 2
输出	-1
说明	有 2 个积木，没有积木数字相同，返回 -1。

---

解读与分析

题目解读：

给出一串数字，如果这些数字没有相同的，返回 -1。如果数字中有相同的，计算每个相同数字最远的距离（如一组数字中有 3 个 5，需计算 第 1 个 5 和 第 3 个 5 的距离，因为它们最远）。
最后输出所有最远距离中的最大值。

分析与思路：

实现步骤如下：
1. 初始化，把输入的数字放到数组 numArr 中。
2. 创建一个Map（设为 numMap），其 key 为 numArr 中的数字值，value 为一个包含 2个 int 元素的数组（设为 itemArr），其中 item[0] 为 key 在数组 numArr 中第一次出现的下标，item[1] 为 key 在数组 numArr 中最后一次出现的下标。
3. 遍历数组 numArr，设当前元素下标为 i。判断 numArr[i] 在 numMap 中是否存在，如果不存在，给 numMap 增加一个元素，key 为 i，value为 包含 2 个元素数组 item（初始值均为 0），其中 item[0] = i 。如果 numArr[i] 在 numMap 中存在，则意味着 value 的 item[0] 已经赋值，此时给 item[1] 赋值 i。
4. 遍历完数组 numArr 后， numMap 中记录了所有出现的数字，以及每个数字第一次出现和最后一次出现的位置（当一个数字只出现了一次，那么最后一次出现位置的值为 0）。遍历 numMap，计算 item[1] - item[0] 的最大值，设为 maxValue。如果 maxValue 小于或等于 0，则意味没有重复的数字，返回 -1。否则 输出 maxValue。

此算法的时间复杂度为 O(n)，空间复杂度为 O(n)。

---

代码实现

Java代码

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;

/**
 *  相同数字的积木游戏1
 * 
 * @since 2023.11.02
 * @version 0.1
 * @author Frank
 *
 */
public class BlockMaxDistance {

    public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	while (sc.hasNext()) {
	    
	    String input = sc.nextLine();
	    int count = Integer.parseInt( input );
	    
	    int[] numArr = new int[count];
	    for( int i = 0; i < count; i ++ )
	    {
		input = sc.nextLine();
		int value = Integer.parseInt( input );
		numArr[i] = value;
	    }
	    processBlockMaxDistance( numArr );

	}

    }

    private static void processBlockMaxDistance(int[] numArr) {
	Map<Integer, int[]> numMap = new HashMap<Integer, int[]>();
	for( int i = 0; i < numArr.length; i ++ )
	{
	    Integer key = numArr[i];
	    int[] item = numMap.get( key );
	    if( item == null )
	    {
		item = new int[2];
		item[0] = i;
		numMap.put( key,  item );
	    }else
	    {
		item[1] = i;
	    }
	}
	
	int maxDistance = 0;
	for( Iterator<Integer> iter = numMap.keySet().iterator(); iter.hasNext();)
	{
	    Integer key = iter.next();
	    int[] item = numMap.get( key );
	    int distance = item[1] - item[0];
	    if( distance > maxDistance )
	    {
		maxDistance = distance;
	    }
	}
	if( maxDistance == 0 )
	{
	    maxDistance = -1;
	}
	System.out.println( maxDistance );
    }

}

JavaScript代码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void async function() {
    while (line = await readline()) {
        var count = parseInt(line);

        var numArr = new Array();
        for (var i = 0; i < count; i++) {
            line = await readline();
            var value = parseInt(line);
            numArr[i] = value;
        }
        processBlockMaxDistance(numArr);
    }
}();

function processBlockMaxDistance(numArr) {
    var numMap = new Map();
    for (var i = 0; i < numArr.length; i++) {
        var key = numArr[i];
        var item = numMap.get(key);
        if (item == null) {
            item = [0, 0];
            item[0] = i;
            numMap.set(key, item);
        } else {
            item[1] = i;
        }
    }

    var maxDistance = 0;
    for ( let [key, value] of numMap ) {
        var item = value;
        var distance = item[1] - item[0];
        if (distance > maxDistance) {
            maxDistance = distance;
        }
    }
    if (maxDistance == 0) {
        maxDistance = -1;
    }
    console.log(maxDistance);
}

(完)