Question

问题：给定一个整数数组，找到并打印可从数组中选择的最大整数数，这样任意两个选定整数之间的绝对差值为＆lt; = 1

输入：

4 2 3 4 4 9 98 98 3 3 3 4 2 98 1 98 98 1 1 4 98 2 98 3 9 9 3 1 4 1 98 9 9 2 9 4 2 2 9 98 4 98 1 3 4 9 1 98 98 4 2 3 98 98 1 99 9 98 98 3 98 98 4 98 2 98 4 2 1 1 9 2 4

输出： 22

根据我的代码，98和99的数字组合加起来为21，因为有二十个数字98和一个99.但是所需的输出是22。

public class Solution {

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int[] a = new int[n];
    for(int a_i=0; a_i < n; a_i++){
        a[a_i] = in.nextInt();
    }

    HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
    for(int i=0;i<n;i++){
        if(hashMap.containsKey(a[i])){
            hashMap.put(a[i], hashMap.get(a[i]) +1);
        }
        else{
            hashMap.put(a[i],1);
        }
    }

    int max_value = 0;
    int max_key = 0;
    for(Integer i : hashMap.keySet()){
        if(hashMap.get(i)>max_value){
            max_value = hashMap.get(i);
            max_key = i;
        }
    }

    Integer max_key_1 = null;
    Integer max_key__1 = null;
    Integer max_value_1 = null;
    Integer max_value__1 = null;

    if(hashMap.containsKey(max_key+1)){
        max_key_1 = max_key+1;
        max_value_1 = hashMap.get(max_key_1);
    }
    if(hashMap.containsKey(max_key-1)){
        max_key__1 = max_key-1;
        max_value__1 = hashMap.get(max_key__1);
    }

    if(max_key_1 != null && max_key__1 != null){
        System.out.println(max_value+Math.max(max_value_1, max_value__1));
    }
    if(max_key_1 != null && max_key__1 == null){
        System.out.println(max_value+max_value_1);
    }
    if(max_key_1 == null && max_key__1 != null){
        System.out.println(max_value+max_value__1);
    }

    System.out.println(hashMap);
    System.out.println("max_key "+max_key);
    System.out.println("max_key_1 "+max_key_1);
    System.out.println("max_key__1 "+max_key__1);

    System.out.println("max_value "+max_value);
    System.out.println("max_value_1 "+max_value_1);
    System.out.println("max_value__1 "+max_value__1);



}

}

Answer 1

所需的输出集由4 s（13）和3 s（9）组成 - 最多可加22。

我将如何解决这个问题，首先是对整个集合进行排序。然后循环遍历数组，注意哪个组有多少成员（即有10 1 s，9 3 s等）。然后简单地比较邻居组（如果他们的差异是<=1）寻找最高计数。我认为这可以一次完成。

整体算法复杂度为O（n.log n）（由于排序）。

希望这是有道理的。

Answer 2

由于输入大小足够小，可以使用计数排序的O(N)算法

（我知道它是C ++，但算法就像3行一样简单，包括I / O）

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int n, a[105] = {0}, ans = 0;
int main() {
    cin >> n;
    for(int i=0,x; i<n; i++) cin >> x, a[x]++;
    for(int i=1; i<=100; i++) ans = max(ans, a[i] + a[i+1]);
    cout << ans << endl;
    return 0;
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[105];
        int ans = 0;
        for(int i=0, x; i < n; i++){
            x = in.nextInt();
            a[x]++;
        }
        for(int i=1; i<=100; i++) ans = Math.max(ans, a[i] + a[i+1]);
        System.out.println(ans);
    }
}

Answer 3

===> ** JavaScript **

function pickingNumbers(arr) {
  // Write your code here
  let arr1 = [];
  for (let i = 0; i < arr.length; i++) {
    let arr2 = [arr[i]];
    for (let j = 0; j < arr.length; j++) {
      let breakCall = false;
      for (let k = 0; k < arr2.length; k++) {
        if (!checkDiff(arr[j], arr2[k])) {
          //   console.log(arr[j], arr2[k], j, k, arr2);
          breakCall = true;
          break;
        }
      }

      //   if([55].includes(arr[i]) && [55,56].includes(arr[j])  && i != j){
      //   console.log(arr[i],arr[j],i,j,arr2)
      //   }
      if (!breakCall) {
        if (checkDiff(arr[i], arr[j]) && i != j) {
          arr2.push(arr[j]);
        }
      }
    }
    // arr2.push(arr[i])
    arr1.push(arr2);
    // break;
  }
  //   console.log(arr1);
  //   return;
  for (let i = 0; i < arr1.length; i++) {
    let breakCall = false;
    // console.log(arr1[i]);
    for (let j = 0; j < arr1[i].length; j++) {
      for (let k = 0; k < arr1[i].length; k++) {
        if (!checkDiff(arr1[i][j], arr1[i][k])) {
          //   console.log(arr1[i][k], j, k);
          breakCall = true;
          break;
        }
      }
    }
    if (breakCall) {
      arr1[i].push(false);
    } else {
      arr1[i].push(true);
    }
    // break;
  }

  //   console.log(arr1);
  //   return;

  let arr1Temp = [];
  let maxLength = 0;
  arr1.forEach(e => {
    if (e[e.length - 1] == true && maxLength < e.length) {
      maxLength = e.length - 1;
    }
    if (e[e.length - 1] == true) {
      e.splice(e.length - 1, 1);
      arr1Temp.push(e);
    }
  });
  arr1 = arr1Temp;

  arr1Temp = [];
  arr1.forEach(e => {
    if (e.length == maxLength) {
      arr1Temp.push(e);
    }
  });
  arr1 = arr1Temp;

  // console.log(maxLength, arr1);
  console.log(maxLength);
  return maxLength;
}

let checkDiff = (a, b) => {
  return Math.abs(a - b) == 1 || Math.abs(a - b) == 0 ? true : false;
};

算法 - 选择数字。以下输出应该是什么？ 21或22？

3 个答案: