Educational Codeforces Round 69

[zwwhdls]

昨天死在 A 题上了(:з」∠)

A 题

题意：给你 n 个木棍 ，求出可以组成楼梯的最大台阶数。 根据题意可列出方程：

1. k <= max2 -1 (max2 为第二大数)
2. k <= n - 2 即求得 max2 - 1 和 n - 2 取最小就好了。

package main

import "fmt"

func main() {
    var tesNum int

    _, err := fmt.Scanln(&tesNum)
    if err != nil {
    }

    var vKey = 0
    for i := 0; i < tesNum; i++ {
        _, err := fmt.Scanln(&vKey)
        if err != nil {
        }
        var vValue = make([]int, vKey)
        var max = [2] int{0, 0}

        for j := 0; j < vKey; j++ {
            _, err = fmt.Scan(&vValue[j])
            if err != nil {
            }

            if vValue[j] > max[0] {
                max[1] = max[0]
                max[0] = vValue[j]
                continue
            }
            if vValue[j] > max[1] {
                max[1] = vValue[j]
            }
        }

        v1 := max[1] - 1
        v2 := vKey - 2
        if v1 <= v2 {
            fmt.Println(v1)
        } else {
            fmt.Println(v2)
        }
    }
}

然后！第一个 case 就挂！！最后经 @BLF2 同学指导，发现是输入可能以空格结束，用 Scan 可以，用 Scanln 就不行。(╯‵□′)╯︵┻━┻

后来用 Py 过的：

if __name__ == "__main__":
    test_num = int(input())
    while test_num:
        test_num -= 1

        arr_num = int(input())
        arr = input()
        num = [int(n) for n in arr.split()]

        num = sorted(num)
        result = min(num[-2] - 1, arr_num - 2)
        print(result)

总结： 不用 Scanln 获取输入！！！

[zwwhdls]

B 题

题意：有 n 个柱子，每个柱子上有一个半径为 ai 的圆盘，要求按从大到小的顺序叠起来；有以下几点限制：

1. 圆盘移动到另一个圆盘上后，不能再被移走；
2. 圆盘只能向两边移动； 如果能叠起来，输出 YES；如果不能，输出 NO

思路：先找到半径最大的圆盘，记录下该圆盘半径为 max，开始向两边遍历，依次看两边的数是否比 max 小，如果是，将 max 置为该值，再向两边移动。一旦遇到比 max 大的，输出 NO；若全部遍历完，输出 YES.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    input := bufio.NewReader(os.Stdin)
    var num int

    _, err := fmt.Fscanf(input, "%d\n", &num)
    if err != nil {
    }

    var pillar = make([]int, num)
    var index, max int

    for i := 0; i < num; i++ {
        _, err := fmt.Fscanf(input, "%v", &pillar[i])
        if pillar[i] > max {
            max = pillar[i]
            index = i
        }
        if err != nil {
        }
    }

    for i, j := 1, 1; ; {
        left := 0
        right := 0
        if index-i >= 0 {
            left = pillar[index-i]
        }
        if index+j < num {
            right = pillar[index+j]
        }
        if index-i < 0 && index+j >= num {
            break
        }

        if left < max && left >= right {
            max = left
            i++
            continue
        }
        if right < max && right > left {
            max = right
            j++
            continue
        }
        fmt.Println("NO")
        return
    }
    fmt.Println("YES")

}