2026-02-26：锯齿形数组的总数Ⅰ。用go语言，给定三个整数 n、l、r，要求构造长度为 n 的数组，元素取自区间 [l, r]，并满足以下两条规则

package main

import (
    "fmt"
)

func zigZagArrays(n, l, r int) (ans int) {
    const mod = 1_000_000_007
    k := r - l + 1
    f := make([]int, k)
    for i := range f {
        f[i] = 1
    }

    for i := 1; i < n; i++ {
        if i%2 > 0 { // 增
            pre := 0
            for j, v := range f {
                f[j] = pre % mod
                pre += v
            }
        } else { // 减
            suf := 0
            for j := k - 1; j >= 0; j-- {
                v := f[j]
                f[j] = suf % mod
                suf += v
            }
        }
    }

    for _, v := range f {
        ans += v
    }
    return ans * 2 % mod
}

func main() {
    n := 3
    l := 4
    r := 5
    result := zigZagArrays(n, l, r)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

def zigZagArrays(n, l, r):
    mod = 1_000_000_007
    k = r - l + 1
    
    # f[j] 表示以值 l+j 结尾的当前长度的序列个数
    f = [1] * k
    
    for i in range(1, n):
        if i % 2 == 1:  # 奇数索引，需要上升
            pre = 0
            for j in range(k):
                # 对于位置 j，前面所有更小的数都可以接在它前面
                # 因为当前长度需要上升，所以结尾数字 j 前面必须小于 j
                pre_val = pre
                pre = (pre + f[j]) % mod
                f[j] = pre_val
        else:  # 偶数索引，需要下降
            suf = 0
            for j in range(k-1, -1, -1):
                # 对于位置 j，后面所有更大的数都可以接在它前面
                # 因为当前长度需要下降，所以结尾数字 j 前面必须大于 j
                suf_val = suf
                suf = (suf + f[j]) % mod
                f[j] = suf_val
    
    # 求和所有可能的结尾值
    ans = sum(f) % mod
    
    # 乘以2的原因：题目可能要求两种方向（先增后减或先减后增）
    # 但这里已经处理了奇偶的情况，可能需要根据实际题目调整
    return (ans * 2) % mod

def main():
    n = 3
    l = 4
    r = 5
    result = zigZagArrays(n, l, r)
    print(result)

if __name__ == "__main__":
    main()

#include <iostream>
#include <vector>
using namespace std;

constint MOD = 1000000007;

long long zigZagArrays(int n, int l, int r) {
    int k = r - l + 1;

    // f[j] 表示以值 l+j 结尾的当前长度的序列个数
    vector<long long> f(k, 1);

    for (int i = 1; i < n; i++) {
        if (i % 2 == 1) {  // 奇数索引，需要上升
            long long pre = 0;
            for (int j = 0; j < k; j++) {
                long long v = f[j];
                f[j] = pre % MOD;
                pre = (pre + v) % MOD;
            }
        } else {  // 偶数索引，需要下降
            long long suf = 0;
            for (int j = k - 1; j >= 0; j--) {
                long long v = f[j];
                f[j] = suf % MOD;
                suf = (suf + v) % MOD;
            }
        }
    }

    // 求和所有可能的结尾值
    long long ans = 0;
    for (int j = 0; j < k; j++) {
        ans = (ans + f[j]) % MOD;
    }

    // 乘以2的原因：题目可能要求两种方向（先增后减或先减后增）
    // 但这里已经处理了奇偶的情况，可能需要根据实际题目调整
    return (ans * 2) % MOD;
}

int main() {
    int n = 3;
    int l = 4;
    int r = 5;
    long long result = zigZagArrays(n, l, r);
    cout << result << endl;
    return0;
}