1 小欧的卡牌

刚开始没想到用动态规划做，稍参考提示才做出来

dp数组用于记录在每一步选择中，当前数字之和模 3 的结果对应的方案数

在dp数组计算过程中就需要取余数，否则大数相加会导致精度丢失

最后打印结果也别忘了取余，因为还有可能大于10^9+7

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

let input = []

readline.on('line', (line) => {
    input.push(line)
})

readline.on('close', () => {
    let n = Number(input[0])
    let a = []
    let b = []
    for (let i = 1; i <= n; i ++) {
        let [tempA, tempB] = input[i].split(' ').map(Number)
        a.push(tempA)
        b.push(tempB)
    }
    
    let dp = Array.from({length: n}, () => 
        Array.from({length: 3}, () => 0)
    )
    
    // 第一张牌
    dp[0][a[0] % 3] += 1
    dp[0][b[0] % 3] += 1
    
    for (let i = 1; i < n; i ++) {
        // 遍历
        for (let j = 0; j < 3; j ++) {
            if (dp[i - 1][j] === 0) {
                continue
            } else {
                dp[i][(a[i] + j) % 3] += dp[i - 1][j] % (1000000000 + 7)
                dp[i][(b[i] + j) % 3] += dp[i - 1][j] % (1000000000 + 7)
            }
        }    
    }
    
    console.log(dp[n - 1][0] % (1000000000 + 7))
})

2 组装手机

对哈希表和集合没有烂熟于心，导致没想出来。逻辑不难 [事后诸葛亮：)

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

let input = []

readline.on('line', (line) => {
    input.push(line)
})

readline.on('close', () => {
    let n = Number(input[0])
    
    let hashMapA = new Map()
    let hashMapB = new Map()
    
    let arrA = input[1].split(' ').map(Number)
    let arrB = input[2].split(' ').map(Number)
    
    let s = new Set()
    
    // 集合：所有和的情况
    for (let i = 0; i < arrA.length; i ++) {
        for (let j = 0; j < arrB.length; j ++) {
            if (s.has(arrA[i] + arrB[j])) {
                continue
            } else {
                s.add(arrA[i] + arrB[j])
            }
        }
    }
    
    // 建立哈希表
    for (let i = 0; i < n; i ++) {
        if (hashMapA.has(arrA[i])) {
            // 若哈希表中有当前遍历值
            hashMapA.set(arrA[i], hashMapA.get(arrA[i]) + 1)
        } else {
            // 没有当前值
            hashMapA.set(arrA[i], 1)
        }
        
        if (hashMapB.has(arrB[i])) {
            // 若哈希表中有当前遍历值
            hashMapB.set(arrB[i], hashMapB.get(arrB[i]) + 1)
        } else {
            // 没有当前值
            hashMapB.set(arrB[i], 1)
        }
    }
    
    let res = -1
    
    // 遍历每一种和情况
    for (let tempSum of s) {
        let tempRes = 0
        // 遍历arrA中每一个键值对
        for (let [x, y] of hashMapA) {
            // y是x出现的次数
            tempRes += Math.min(y, hashMapB.get(tempSum - x) || 0) 
            
            if (tempRes > res) {
                res = tempRes
            }
        }
    }
    
    console.log(res)
})

3 小欧的平均数

这个题目对于平均的定义压根没说明白，不好玩

我以为是，让其中一个数通过若干次加减，等于其余两个数平均值的最小步骤。结果是让三个数变成全奇或全偶的最小次数，这还谈及平均数干啥嘞？？？

``

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

let input = []

readline.on('line', (line) => {
    input.push(line)
})

readline.on('close', () => {
    let [x, y, z] = input[0].split(' ').map(Number)
    
    let res = 0
    
    if (x % 2 === 0) res ++
    if (y % 2 === 0) res ++
    if (z % 2 === 0) res ++

    console.log(Math.min(res, 3 - res))
})