看题第一反应是主席树。

定义 $lst[x]$ 表示值 $x$ 出现的下标（因为是排列只会出现一次），则每次询问中要求的区间排名即为 $lst$ 上 $p[c]$ 左侧在 $[l,r]$ 之间的数的个数，加上 $l$ 就是答案。使用扫描线——离线树状数组解决即可。（如果你没有学过二位数点，类比树状数组求逆序对即可）。

赛时代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

int n, m;
cin >> n >> m;

vector<int> p(n + 1);
for (int &num : p | views::drop(1)) {
    cin >> num;
}

struct Query {
    int l, r, c, id;
};

vector<vector<Query>> queryByCVal(n + 1);
for (int i = 0; i < m; i++) {
    Query query;
    auto &[l, r, c, id] = query;
    cin >> l >> r >> c;
    id = i;
    queryByCVal[p[c]].push_back(query);
}

vector<int> lst(n + 1);
for (int i = 1; i <= n; i++) {
    lst[p[i]] = i;
}

Fenwick<int> tree(n);
vector<int> ans(m);

for (int val = 1; val <= n; val++) {
    for (auto q : queryByCVal[val]) {
        ans[q.id] = tree.GetSum(q.r) - tree.GetSum(q.l - 1) + q.l;
    }

    tree.Add(lst[val], +1);
}

for (int num : ans) {
    cout << num << '\n';
}

H 小鸡的排列构造

我讨厌构造题…

猜测无论输入如何都存在满足条件的排列（即任意奇数或者偶数长度区间都是全错排），试着构造：

当 $r - l + 1$ 为奇数时：$n=3$ 的情况平凡，2 3 1 或者 3 1 2。以前者为例，考虑以此构造 $n=4$ 的情况，设第 4 位为 x，由于后三位 3 1 x 必须满足全错排，因此只能是 2 3 1 1.5 的大小关系，即 3 4 1 2。同理构造 $n=5$ 的情况：3 4 1 2 0.5 即 4 5 2 3 1，以此类推，不难看出规律 n-1,n,n-3,n-2,...。（如果从 3 1 2 出发能得到另一组构造）。

不太清楚“对于一个任意长度为 3 的区间都是全错排的排列，任意长度为 5, 7, 9… 的区间也是全错排”怎么形式化的理解或证明，但是观察我们构造出的序列显然是满足的。

$r - l + 1$ 为偶数时同理，可以得到构造 n, n-1, n-2, n-3, ...。

赛时代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

int n, m;
cin >> n >> m;

int parity = 0;
for (int i = 1; i <= m; i++) {
    int l, r, c;
    cin >> l >> r >> c;
    parity = (r - l + 1) & 1;
}

if (parity == 1) {
    for (int i = n - 1; i >= 1; i -= 2) {
        cout << i << ' ' << i + 1 << ' ';
    }
    if (n % 2 == 1) {
        cout << 1;
    }
    cout << '\n';
}
else {
    for (int i = n; i >= 1; i--) {
        cout << i << ' ';
    }
    cout << '\n';
}

D Viva La Vida(Fried-Chicken’s Version)

虽然题目是无向边，但是我们先将其看作有向边。画个简单的图，结论其实就一目了然：

（剩下的边用更大的数补全即可）

边权就类似势能一样，从高走向低，因此不能成环（重边除外）。由于出度为 1，所以每个联通分量一定有且仅有一个重边，所以数重边个数即可。

由于边权是排列，没有相等的数，也就是说对于一条重边，它的边权就是和这两个点相连的 $2n-3$ 条边里最小的一条，概率 $\cfrac{1}{2n-3}$。由期望的线性性，总期望就是每一条边的期望之和， 即 $\cfrac{C_n^2}{2n-3}$。

代码略。

E 任造化落骰

参考官方题解的做法，先用单调栈预处理出 $nxtMax[i]$，即 $i$ 之后下一个改变 $\max$ 的位置，然后枚举左端点 $l$，用双指针处理 $\max \times \min$ 为 $val$ 的二元对的个数，做个后缀和，每次询问二分找要的值就行。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

int n, m, q;
cin >> n >> m >> q;

vector<int> a(n);
for (int &num : a) {
    cin >> num;
}

auto calc = [&](const function<bool(int, int)> &cmp) {
    stack<int> St;
    vector<int> nxt(n);

    for (int i = n - 1; i >= 0; i--) {
        while (St.empty() == false && cmp(a[St.top()], a[i]) == false) {
            St.pop();
        }

        if (St.empty()) {
            nxt[i] = n;
        }
        else {
            nxt[i] = St.top();
        }

        St.push(i);
    }
    return nxt;
};

auto nxtMin = calc(less());
auto nxtMax = calc(greater());

map<ll, ll> bkt;
for (int l = 0; l < n; l++) {
    for (int i = l, j = l; i < n && j < n;) {
        if (nxtMin[i] < nxtMax[j]) {
            bkt[1ll * a[i] * a[j]] += nxtMin[i] - max(i, j);
            i = nxtMin[i];
        }
        else {
            bkt[1ll * a[i] * a[j]] += nxtMax[j] - max(i, j);
            j = nxtMax[j];
        }
    }
}

vector<ll> vals;
vector<ll> sufSum;
for (auto [val, cnt] : bkt) {
    vals.push_back(val);
    sufSum.push_back(cnt);
}

for (int i = sufSum.size() - 2; i >= 0; i--) {
    sufSum[i] += sufSum[i + 1];
}

while (q--) {
    ll k;
    cin >> k;

    int ind = ranges::lower_bound(vals, k) - vals.begin();
    cout << sufSum[ind] << '\n';
}

按网上的教程配置 github actions, 在 hexo generate 的时候无法解析文章里的 tag plugins(标签插件) 而是会报错. 我一开始还以为是插件没装上, 后来才意识到, 我的主题是直接在 themes 文件夹里 git clone 过来的, actions 中 clone 我的仓库是不包含这个主题的, 所以才报错. git 仓库嵌套使用后, 被嵌套的 git 仓库不能被外层 git 仓库检测到. 百度~~(其实是bing但我说习惯了)~~后发现 git 还有 submodule 这种东西, 刚好可以达到我们的目的.

首先要用 git rm --cached 删除原来的内层仓库, 不要直接删除, 否则外层可能会感知不到, 然后输入命令:

1

git submodule add -b [branch] [repository_url] [path]

例如:

1

git submodule add -b master https://github.com/jerryc127/hexo-theme-butterfly.git themes\butterfly

正确运行之后除了拉取到的仓库应该还会在根目录多出一个 .gitmodules 文件. 如果出现问题想要删除 submodule 请用 git submodule deinit [path] 命令.

这之后直接 git clone 实际上并不会拉取到 submodule 中的代码, 应该在 git clone 命令中带上参数 --recurse-submodules 表示递归拉取所有子模块, 或者执行下面的命令:

1
2

git submodule init
git submodule update

言归正传, 对于 github actions 来说, 如果你用的是 actions/checkout, 只需要在 with 里加一行 submodules: true 或者 submodules: recursive 即可, 否则参照上文如何拉取子模块.

deploy repo

改完后生成似乎没问题了, 但依然部署不上, 报错:

将 _config.yml 中 deploy 的 repo 更换一下就行了(参见):

1
2
3
4
5

deploy:
  type: git
  # repo: https://github.com/[yourgitname]/[yourgitname].github.io.git
  repo: git@github.com:[yourgitname]/[yourgitname].github.io.git
  branch: master

但在我的win10电脑能部署, github actions 却不行, 或许是 windows 和 Ubuntu linux 的差异吧, 也有可能是别的问题, 不太清楚, 反正解决了就行了.

更新时间错误

因为 git clone 后文件的修改时间实际上是 clone 的时间, 所以没在 front-matter 填写 updated 的文章的更新时间全都是 clone 的时间. 只要把文件的修改时间变为该文件最后 commit 的时间, 在生成之前加一行命令即可:

1

find source/_posts -name '*.md' | while read file; do touch -d "$(git log -1 --format="@%ct" "$file")" "$file"; done

参考链接:
修复 CI 构建博客造成的更新时间错误

最近要把WPF项目发布成含运行时(部署模式选择"独立")的单个exe, 想当然的在发布选项里勾选了"生成单个文件", 却仍生成了若干dll, 而且删除便无法运行, 似乎是native dlls. 搜索资料发现还需要在发布配置文件(Properties\PublishProfiles\*.pubxml)中加入一行代码:

1

<IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>

加入后, 运行程序时会先提取出本地库到目录, 某种意义上不算真正的单文件

详情见此 -> 微软官方文档

勾选生成单个文件已经在开头提过了, 后文再补充一些我能想到的其他未能生成单个文件的原因

更改文件保存方式

请在属性选项卡中将图片等文件的"生成操作"(build action)设置为 资源, "复制到输出目录"设置为 不复制, 代码中以路径或Pack URI来使用资源, 也可以用反射读取嵌入的资源

一些文本数值或者其他对象可以用 .resx, .settings, 或者自行实现序列化存到 Appdata\Local 或者参见Configuration 等各种方式来存储

更改.pdb 生成选项

在项目设置中找到"调试符号", 选择"未发出任何符号"或者"嵌入到Dll/exe"
选择前者会导致无法Debug以及 StackTrace 无法输出异常的文件位置和行号, 因此不推荐使用

原地退役

接到正式通知取消了，寄了

我们已经用过很多内置的方法了, 例如 WriteLine(), ToInt32(), Max() 等等, 其实我们也可以定义方法, 定义方法的语法如下:

1
2
3
4

[访问修饰符] 返回值类型 方法名([参数列表])
{
    //方法体
}

让我们以下面这个方法为例, 分析一下定义方法的语法的含义

1
2
3
4

public int Square(int a)
{
    return a * a;
}

这个方法接收一个 int 类型的参数并记为 a, 然后返回 a 的平方

• public 是访问修饰符, 除此之外还有 private, protected 等. 如无特殊说明, 本文中所有的访问修饰符更改都不会影响结果, 先不用在意

• 其中第一个 int 表示的是方法的返回值的类型, 括号里的第一个(也是唯一一个) int 表示接收的第一个参数是 int 类型的, 将这个参数记为 a, 可以在方法体里用 a 来使用

• 方法体就是调用这个方法之后执行的代码片段

• return 关键字表示将后面的值作为方法的返回值, 然后立刻结束该方法

我们需要把这个方法的定义写在 Main 方法外面, 让我们试着像调用 Max() 方法那样调用它:

1
2
3
4
5
6
7
8
9
10
11
12

class Program
{
    public int Square(int a)
    {
        return a * a;
    }

    static void Main(string[] args)
    {
        Console.WriteLine(Square(5));
    }
}

然后会发现报错了:

这句话大家可能看着云里雾里的, 但是也许大概能猜出两点:

1. 对于非静态的xxx是必须的, 那如果是静态的就非必须了?
2. 似乎缺少一个对象?

对于第一种想法只要在方法的定义里加上 static 修饰符就可以了(static 这个词就是"静态"的意思):

1
2
3
4
5
6
7
8
9
10
11
12

class Program
{
    public static int square(int a)
    {
        return a * a;
    }

    static void Main(string[] args)
    {
        Console.WriteLine(square(5));
    }
}

现在就可以正常运行了, 加上 static 修饰符的方法叫做静态方法

我们在第三节"再谈类型"详细讲过什么是"静态", 当时是这么说的:

静态是一种总体的概念，与整个类有关，和每个单独的对象没有关系。

大家还记得 Program 也是一个类吗, 这里的类指的就是 Program 类, 这个方法的返回值只与它接受的参数有关系, 与其他的东西没有关系, 所以可以设定为静态的。

第二种做法需要自己定义一个类

还记得当时我们是怎么使用 Random 类中的 Next() 方法的吗? Random 是一个类, 我们先 new 了一个 Random 类的对象称作 rd, 然后再用 . 调用 rd 对象的方法 Next()

1
2

Random rd = new Random();
int a = rd.Next();

仿照我们代码中的 Program 类, 再定义一个类: (具体有关类的概念会在下一节讲解)

1
2
3
4
5
6
7

class Calculator
{
    public int Square(int a)
    {
        return a * a;
    }
}

然后把这个类和 Program 类并列放在一起, 再用类似的做法调用 Square 方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using System;

namespace csharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator cal = new Calculator();
            Console.WriteLine(cal.square(5));
        }
    }

    class Calculator  // Calculator类的定义从这开始
    {
        public int square(int a)  // 必须使用public
        {
            return a * a;
        }
    }
}

这种没有 static 修饰符的方法叫做非静态方法或者实例方法

因为 square 的结果只与参数 a 有关所以其实在 Calculator 类中也可以使用静态方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

using System;

namespace csharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // 不需要new一个Calculator
            int a = Calculator.Square(5); 
            Console.WriteLine(a);
        }
    }

    class Calculator
    {
        public static int Square(int a)  // 必须使用public
        {
            return a * a;
        }
    }
}

后文均使用静态方法, 但所述内容对实例方法也适用, 而实例方法会在下一节介绍面向对象相关内容用到

void 关键字

方法并不一定要有返回值, 如果想要定义一个没有返回值的方法可以使用 void 关键字代替原来的返回值类型的位置:

1
2
3
4

public static void Output(string name)
{
    Console.WriteLine("My name is" + name);
}

然后正常调用:

1
2
3
4
5
6
7
8
9

public static void Output(string name)
{
    Console.WriteLine("My name is " + name);
}

static void Main(string[] args)
{
    Output("jiangdu");
}

无返回值方法也可以用 return; 来让方法立刻结束:

1
2
3
4
5
6
7
8
9
10
11
12

public static void Output(string name)
{
    if (name == "jiangdu") {
        return;
    }
    Console.WriteLine("My name is " + name);
}

static void Main(string[] args)
{
    Output("jiangdu");
}

上面的代码没有输出

方法的参数

方法的参数可以是任意类型, 也可以有多个参数

1
2
3
4
5

public static double Max(double a, double b)
{
    if (a >= b) return a;
    else return b; 
}

注意多个参数的时候参数的类型可以不同, 但是一定要注意输入的顺序:

1
2
3
4
5
6
7
8
9
10

// Info 常用来表示 Infomation 的缩写
public static void PrintInfo(string name, int index) 
{
    if (index <= 0) {
        Console.WriteLine("序号无效");
    }
    else{
        Console.WriteLine("第{0}个学生: {1}", index, name);
    }
}

调用的时候需要按照参数列表的顺序来:

1
2
3
4
5

static void Main(string[] args)
{
    PrintInfo("jiangdu", 1);  // 正确
    PrintInfo(1, "jiangdu");  // 报错
}

例题5-1 遍历查找

给定一个一维数组, 返回数组中的最大值

1
2
3
4
5
6
7
8
9

static int GetMax(int[] array)
{
    int max = array[0];
    for (int i = 1; i < array.Length; i++) {
        if (array[i] > max)
            max = array[i];
    }
    return max;
}

使用随机数来测试你的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static void Main(string[] args)
{
    int n = 10;
    int[] a = new int[n];  // 开一个大小为 10 的一维数组, 下标范围[0,9]
    Random rd = new Random();  // Random对象不需要每次重新生成, 所以放在循环外面

    for(int i=0; i < n; i++) {
        a[i] = rd.Next(0, 101);  // 左闭右开
        Console.Write(a[i] + " ");
    }

    Console.Write("\n");  // 双引号中的 \n 表示换行符
    // Console.WriteLine();  // 这样也可以直接输出换行
    Console.WriteLine(GetMax(a));
}

引用传递参数

在解释这段的标题前先思考一下, 如何交换两个整数呢? 是x = y; y = x; 吗, 显然不是, 因为在 x = y; 之后, x 保存的就是 y 的值了, 所以 y = x; 之后两个变量保存的都是原来 y 的值

所以应该用一个变量临时存储一下原来 x 的值:

1
2
3

int temp = x;  // 把 x 的值保存到 temp
x = y;  // 把 y 的值保存到 x
y = temp;  // 把 temp 的值(即交换前 x 的值)保存到 y

让我们试着写一个交换两个整数的方法(有BUG):

1
2
3
4
5
6

public static void Swap(int x, int y)
{
    int temp = x;
    x = y;
    y = temp;
}

在主函数中调用这个方法, 然后运行一下

1
2
3
4
5
6

static void Main(string[] args)
{
    int a = 5, b = 10;
    Swap(a, b);
    Console.WriteLine("{0} {1}", a, b);
}

你会发现两个数并没有完成交换, 这就是因为我们传入参数的时候是按值传递的参数

在你传递参数的时候, 传递的只是 a 变量的值 5 和 b 变量的值 10, 在调用的时候把这两个值复制了一遍, 和原来的变量没有关系, 我们只交换了那两个复制之后的值, 而没有交换原来的值(复制出来的值会在方法运行结束后销毁)

这样的设计是为了保护原本的参数不变

方法的参数列表中的 x 和 y 称为形式参数, 简称形参, 是出现在方法的定义中用来代表传入的值的; 而具体调用时的参数 a 和 b 称为实际参数, 简称实参, 出现在调用方法的时候

为了实现 Swap 方法, 就要用到引用

引用参数是一个对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。

如果把变量比作房子, 引用就像是房子的地址, 如果传入的参数是变量的地址的话, 那在方法里也可以按照这个地址找到原来的变量. 所以按引用传参的话, 在方法里也能更改原本的变量

使用 ref 关键字来声明引用参数:

1
2
3
4
5
6

public void Swap(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

现在再测试, 就可以正常执行了

递归

从刚刚在方法里调用 WriteLine() 方法以及 Main 方法能够调用其他方法就能看出, 方法之间是可以互相调用的. 那么, 一个方法能不能调用自身呢? 答案是肯定的, 不过先不要急着写出像下面这样的代码:

1
2
3
4

public static void Function()
{
    Function();
}

如果你试着调用它然后运行, 过几秒或更久之后就会有这样的报错:

由于 Function 方法一直在调用自身, 而内层的方法返回之前外层的 Function 方法不会结束, 而内层的方法又会再次调用 Function, 然后无限重复.

这就有点像大家从小就听过的故事：从前有座山，山里有座庙，庙里有一个老和尚和一个小和尚讲故事。从前有座山，山里有座庙，庙里有一个老和尚和一个小和尚讲故事…

关注刚刚报错信息中的 StackOverflow 这个词, Stack 是栈的意思, 这里指的是调用栈, 你可以理解为是一种只能从上方放东西或者取东西的容器, 每当方法调用的时候就会往里装东西, 例如按值传递的时候会把复制之后的值放在这里; 当方法返回的时候就会把对应的东西拿出来扔掉

StackOverflow 就是栈溢出, 因为那个方法一直在无限重复调用自身, 而每次调用都会往栈里装东西, 但没有方法返回所以不会取出任何东西, 最后装满了放不下了, 然后你的程序就崩溃了.

因此我们需要给调用自身一个终止条件:

1
2
3
4
5
6
7
8
9
10
11
12
13

// 递归的英文是 Recursion
public static void Recursion(int n)
{
    if (n == 0) {
        return;
    }
    Recursion(n-1);
    Console.WriteLine(n);
}
static void Main()
{
    Recursion(5);
}

输出是:

调用过程类似 Recursion(5) -> Recursion(5) -> … -> Recursion(0) 由于到了 n == 0 的时候不再调用自身, 所以 最内层的 Recursion(0) 输出之后可以返回, 之后次内层的 Recursion(1) 就可以输出并返回了…最终 Recursion(5) 可以正常结束

这样方法自己调用自己的技巧就叫做递归

关于递归有很多笑话: 要理解递归，就得先了解什么是递归。

实际上这句话就是一个递归。
了解递归(1) -> 了解递归(2) -> …
当你从这句话中悟出什么是递归的时候, 就可以一层层返回了

注意刚刚代码中的 Recursion(n-1); 和 Console.WriteLine(n); 的顺序, 如果颠倒一下输出就会完全相反

1
2
3
4
5
6
7
8

public static void Recursion(int n)
{
    if (n == 0) {
        return;
    }
    Console.WriteLine(n);
    Recursion(n - 1);
}

因为 Recursion(i) 会先输出自己的 n 的值再调用 Recursion(i - 1), 所以输出会先从 5 开始, 0 结束

例题5-2 斐波那契数列

斐波那契数列的定义:

$$\left\{ \begin{array} { l } { f ( n ) = f ( n - 1 ) + f ( n - 2 ), n \ge 3 } \\ { f ( 1 ) = f(2) = 1 } \end{array} \right.$$

也就是: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55…

输出斐波那契数列的第 x 个数

递归代码:

1
2
3
4
5
6
7

public static int Fib(int n)
{
    if (n == 1 || n == 2) {
        return 1;
    }
    return Fib(n - 1) + Fib(n - 2);
}

由此可见, 数学上的递推公式可以直观的用递归写出来, 很多算法也都是用递归来实现的, 例如dfs

递归时调用的过程是这样的:

注意到这张图里 Fib(3) 以及它下面会调用的方法这个整体会被计算两遍, 因此刚刚的递归会产生大量重复运算, 而使用下文展示的循环对于每个 fib(i) 则只会计算一次, 所以这里用循环会比刚刚那种递归要快很多:

1
2
3
4
5
6
7
8

int n = 10;
int[] fib = new int[n + 1];

fib[1] = fib[2] = 1;
for(int i = 3; i <= n; i++) {
    fib[i] = fib[i - 1] + fib[i - 2];
}
Console.WriteLine(fib[n]);

甚至还可以用技巧来省去数组, 节约内存:

1
2
3
4
5
6
7
8
9

int n = 10;

int first = 1, second = 1, third = 2;
for(int i = 3; i <= n; i++) {
    third = first + second;
    first = second;
    second = third;
}
Console.WriteLine(third);

不过很多更复杂的情况下递归容易写出, 而循环可能非常难写

在 n 的取值大到能体会到速度差别之前就会因为 fib[n] 太大超过 int 的表示范围而输出错误的结果, 如果想测试两段代码的速度的话, 请在过程中对答案取模, 例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

DateTime startTime = DateTime.Now;  // 保存当前时间

int n = 10;
int mod = 1000000000;

int first = 1, second = 1, third = 2;
for(int i = 3; i <= n; i++) {
    third = (first + second) % mod;  // 在这里取模
    first = second;
    second = third;
}
Console.WriteLine(third);

DateTime finishTime = DateTime.Now;  // 保存当前时间
double deltaTime = (finishTime - startTime).TotalMilliseconds;  // 计算时间差

Console.WriteLine("use {0} ms", deltaTime);

递归也可以改写为只计算一次的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public static int Fib(int n, int[] fib)
{
    if (n == 1 || n == 2) {
        return 1;
    }
    if (fib[n] != 0) return fib[n];
    fib[n] = Fib(n - 1, fib) + Fib(n - 2, fib);
    return fib[n];
}

static void Main(string[] args)
{
    int n = 40;
    int[] fib = new int[n + 1];

    Console.WriteLine(Fib(n, fib));
}

这样借助 fib 数组将递归已经计算过的结果存储下来, 避免重复运算, 称为记忆化搜索

数组是一个存储相同类型数据的固定大小的顺序集合。用简单的话来说就是，数组可以用单个变量名来访问很多同一类型的数据，而不需要声明很多的变量。

假设我们正在做一个把所有一共 n 个学生的分数进行排名的程序，那么我们就要储存所有学生的分数，由于 n 可能很大而且不是一个固定的值，所以我们无法为每个学生都声明一个变量来存储，就算那么做也无法进行排名。这时候我们需要使用数组。

声明数组的语法如下：

1

type[] arrayName;  // array 就是数组的英文

例如：

1

int[] scores;

但如果这样使用数组的话会报错：

这是因为数组声明之后并不会初始化，所以还需要在声明的时候使用 new 关键字来创建数组的实例（关于什么是 new 操作符请见上一篇教程 不过暂时不懂问题也不大），例如：

1

int[] scores = new int[5];

其中方括号里的数组表示的是数组的大小，也就是数组中元素的个数。数组的长度是固定的，所以必须说明它的大小。

在定义数组之后，我们可以用 arrayName[index] 来访问叫做 arrayName 的数组中的第 index+1 个元素，其中方括号中的内容叫做数组的下标或者索引(index就是索引的英文)。

你可以在声明的时候对数组中的元素赋初始值，例如：

1

int[] scores = new int[5] { 98, 97, 94, 92, 95 };

此时 scores 数组中第一个元素是 98, 索引是 0, 最后一个元素是95, 索引是 4

使用 scores[index] 访问数组中的元素:

1
2

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
Console.WriteLine(scores[1]);

输出为 97 (注意不是 98, 因为数组从 0 开始计数)

可以这样来更改数组中的元素:

1
2
3

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
scores[1] = 99;
Console.WriteLine(scores[1]);  // 输出 99

如果你试图访问不存在的下标, 例如:

1
2

int[] scores = new int[5];
scores[5] = 1;

会收到这样的报错信息:

翻译过来就是: 下标超过了数组的边界, 也就是"数组越界", 因为数组的 下标从 0 开始, 而这个数组只有 5 个元素, 所以下标范围是[0, 4], 故发生了数组越界.

遍历数组

为了一次性访问数组中的诸多元素, 可以使用第二节学过的循环:

1
2
3
4

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
for (int i = 0; i < 5; i++) {  // 注意这里的条件
    Console.WriteLine(scores[i]);
}

输出估计大家都能猜到：

也可以试试用循环进行初始化

1
2
3
4

int[] scores = new int[5];
for (int i = 0; i < 5; i++) {  // 注意这里的条件
    scores[i] = i;
}

当你不知道数组有多大的时候，可以使用 arrayName.Length 访问数组的长度，上面的代码可以写为：

1
2
3
4

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
for (int i = 0; i < scores.Length; i++) {  // 注意这里的条件
scores[i] = i;
}

注意 Length 后面不要写括号，因为这不是个函数，而是一个属性

为了方便起见, 你也可以不用索引为 0 的元素, 比如要存 5 个元素的时候写为这样:

1
2
3
4

int[] scores = new int[6];
for (int i = 1; i <= 5; i++) {
    scores[i] = i;
}

foreach 语句

其实我们有更简单的循环的语句，之前在讲循环的时候因为没学数组所以没讲，就是使用 foreach 语句

类似 python 中的 for item in array:，你可以直接用 foreach 来访问数组中的每一个值，例如：

1
2
3
4

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
foreach (int i in scores) {
    Console.WriteLine(i);              
}

i 本身代表数组中的一个元素，而不是索引，所以应该直接输出 i

请注意 foreach 语句中的 i 是不能被赋值的, 也就是说只能用 foreach 来查询数组中的值而不能用来赋值

例题 4-1 最高分

求所有学生中的最高分数

1
2
3
4
5
6

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
int maxScore = 0;
foreach (int item in scores) {
    maxScore = Math.Max(item, maxScore);
}
Console.WriteLine(maxScore);

其中 Math.Max() 是一个我们之前没有用过的函数, 不过顾名思义, 就是返回两个数中的最大值（double 等数据类型也是可以的）

如果你不愿意使用这个函数, 可以改为：

1
2
3
4
5
6

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
int maxScore = 0;
foreach (int item in scores) {
    if (maxScore < item) maxScore = item;
}
Console.WriteLine(maxScore);

也就是说只在 maxScore 比 item 小的时候才用 item 更新 maxScore, 这样 maxScore 就是 scores 数组中的最大值了

那么回到本文最开始的问题, 怎么给 n 个学生的分数进行排名呢, 不用想怎么实现排序, 因为 c# 有给数组排序的函数: Array.Sort(arrayName)
这里的 Array 是一个类, 包含很多与数组有关的函数

1
2

int[] scores = new int[5] { 98, 97, 94, 92, 95 };
Array.Sort(scores);

这样就给 scores 数组排好序了, sort 排序默认是从小到大, 所以我们可以反着遍历数组来输出从大到小的值

完成了最初的目标, 再改为需要读入数据的版本：

1
2
3
4
5
6
7
8
9
10
11
12

int n = Convert.ToInt32(Console.ReadLine());  // 学生总数

int[] scores = new int[n];
for (int i = 0; i < n; i++) {
    scores[i] = Convert.ToInt32(Console.ReadLine());  // 每个学生的分数
}

Array.Sort(scores);

for (int i = n - 1; i >= 0; i--) {
    Console.WriteLine(scores[i]);
}

如果你嫌倒着遍历麻烦可以使用 Array.Reverse() 来翻转数组, 这样就能正着遍历了:

1
2
3
4
5
6
7

// 前面的代码相同, 略去
Array.Sort(scores);
Array.Reverse(scores);

for (int i = 0; i < n; i++) {
    Console.WriteLine(scores[i]);
}

Sort 有很多重载, 其中一个是 Sort(arrayName, index, length) , index 是排序范围的起始索引, length 是排序的元素个数
Reverse 也有类似的用法

所以要空过去第 0 个的话, 应该改为:

1
2
3
4
5
6
7
8
9
10
11
12
13

int n = Convert.ToInt32(Console.ReadLine());  // 学生总数

int[] scores = new int[n+1];  // 因为后面空过去了第 0 个元素所以这里要声明为 n+1, 否则会数组越界
for (int i = 1; i <= n; i++) {
    scores[i] = Convert.ToInt32(Console.ReadLine());
}

Array.Sort(scores, 1, n);
Array.Reverse(scores, 1, n);

for (int i = 1; i <= n; i++) {
    Console.WriteLine(scores[i]);
}

再加点细节:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Console.Write("请输入学生总数: ");
int n = Convert.ToInt32(Console.ReadLine());

int[] scores = new int[n+1]; 
for (int i = 1; i <= n; i++) {
    Console.Write("请输入第{ 0 }个学生的分数: ", i);
    scores[i] = Convert.ToInt32(Console.ReadLine());
}

Array.Sort(scores, 1, n);
Array.Reverse(scores, 1, n);

for (int i = 1; i <= n; i++) {
    Console.WriteLine("第{ 0 }名的分数: { 1 }", i, scores[i]);
}

扩展阅读

你会发现，这样我们只对分数进行了排序，而没法将分数与人名对应, 做法有很多种, 这里只介绍其中一种

可以想到, 我们需要的是一个 能够同时保存 int 类型的数和 string 类型的字符串的类型, 再定义这个类型的数组(之前说过可以声明更复杂类型的数组), 再用 Sort 对它进行排序, 而我们还没学过自定义类型, 怎么办呢

好在 c#4.0 提供了 Tuple 类型(中文为元组), 可以由多个元素组成(最多8个), 用 tupleName.Item1 访问第一个元素(以此类推)

用 Tuple<int, string> 来表示第一个元素为 int 类型, 第二个元素为 string 类型的 Tuple

所以我们创建一个 Tuple<int, string> 类型的数组
Tuple 类型已经写好了 < 操作符, 先比较第一个元素的大小, 如果相等再比较第二个(以此类推), 所以可以直接使用 Sort

据此可以将上面的代码改为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Console.Write("请输入学生总数: ");
int n = Convert.ToInt32(Console.ReadLine());

Tuple<int, string>[] scores = new Tuple<int, string>[n + 1];
for (int i = 1; i <= n; i++) {
    Console.Write("请输入第{ 0 }个学生的姓名: ", i);
    string b = Console.ReadLine();
    Console.Write("请输入第{ 0 }个学生的分数: ", i);
    int a = Convert.ToInt32(Console.ReadLine());

    scores[i] = Tuple.Create(a, b);
}

Array.Sort(scores, 1, n);
Array.Reverse(scores, 1, n);

for (int i = 1; i <= n; i++) {
    Console.WriteLine("第{ 0, -2 }名:  { 1, -5 }{ 2, -5 }", i, scores[i].Item1, scores[i].Item2);
}

最后输出时的占位符 { 0, -2 } 中, 第一个参数 0 的意思与之前的 { 0 } 一样, 表示后面下标为 0 的对象, -2 (的绝对值)表示输出的长度, 不足的补成空格, 负号表示左对齐(没有负号表示右对齐), 这样是为了输出的时候同一列数据可以左对齐, 好看一点, 你也可以不用

数组相关函数

这里介绍一些相对常用的函数

Array.Clear()

用来清空数组

1
2

Array.Clear(arrayName);
Array.Clear(arrayName, index, length);

strName.Split()

注意这个不是对数组进行操作
这个函数的用处是, 将一个字符串按照你输入的分隔符分成由若干个字符串组成的 string 数组, 然后返回这个 string 数组

1

stringName.Split(Seperator);

使用例:

1
2
3
4
5

string a = "a ab abc abcd";
string[] strArray = a.Split(" ");
foreach(string i in strArray) {
    Console.WriteLine(i);
}

这里会按空格来把 a 字符串分成四个字符串, 存到 strArray 这个字符串数组中

用这种方法我们就可以在一行内读入多个数据了

例题 4-2 逆序输出

一行输入若干个整数, 在一行内倒序输出它们

1
2
3
4
5

string temp = Console.ReadLine();
string[] a = temp.Split(" ");
for (int i=a.Length-1; i >= 0; i--) {
    Console.Write("{ 0 } ", a[i]);
}

二维数组

之前说过可以声明更复杂类型的数组, 那么大家想没想过, 数组中的元素也可以是另一个数组呢!

数组中的子数组长度是可以不相同的, 那种叫做交错数组, 不太常用, 不在本文讨论范围之内
c# 中的二维数组仅指每个子数组的长度都相同的那种

一个包含 x 个子数组, 其中每个子数组有 y 个元素的二维数组可以被看做一个 x 行 y 列的表格

声明二维数组的语法如下:

1

type[,] array = new type[x, y];

例如声明一个 3 行 4 列的数组并初始化:

1
2
3
4
5

int[,] a = new int[3, 4] { 
    { 0, 1, 2, 3 }, 
    { 4, 5, 6, 7 }, 
    { 8, 9, 10, 11 } 
};

换行是为了方便阅读, 当然是可以删掉的, 写成:

1

int[,] a = new int [3, 4] { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } };

我们可以用 a[i, j] 来访问这个二维数组中第 i 行 第 j 列的元素, 例如:

1
2

int[,] a = new int [3,4] { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } };
Console.WriteLine(a[1, 2]);

从本质上讲, a[1] 访问的是 a 中的第 1 个元素(从 0 开始), 也就是一个数组 { 4, 5, 6, 7 }
而例如 a[1, 2] 也就是访问 a[2] 中的第 2 个元素, 也就是 数组 { 4, 5, 6, 7 } 中的第 2 个元素, 所以 a[i, j] 为 6

不过在平时使用时不需过多关注它本质的意思, 当成表格就好

循环访问二维数组的元素如下:

1
2
3
4
5
6

int[,] a = new int [3,4] { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } };
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        Console.WriteLine("({ 0 }, { 1 }): { 2 }", i, j, a[i, j]);
    }
}

其实 foreach 也可以遍历二维数组中的所有元素, 但是一般情况下我们可能会需要数据的坐标(指位于的行和列), 那种情况下就不能用了

1
2
3
4

int[,] a = new int [3,4] { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } };
foreach(int item in a) {
    Console.WriteLine(item);
}

综合运用: 扫雷的棋盘生成

大家都玩过扫雷吧, 我们这里做一个 mapRow × mapColumn 大小的棋盘(二维数组), 上面有 mineNum 个雷
我们用 map[i] 表示这个格子周围雷的数量, 如果为 -1 则表示这个格子就是雷

先声明一下:

1
2

int mapRow = 10, mapColumn = 10, mineNum = 10;
int[,] map = new int[mapRow+1, mapColumn+1];

然后声明一下随机数要用的 Random 对象:

1

Random rd = new Random();

然后循环访问随机位置, 把它设成雷:

1
2
3
4
5
6
7
8
9

for (int cnt=1; cnt <= mineNum; ) {  // cnt 表示正在放第 cnt 个雷, 注意这后面没写 cnt++
    int x = rd.Next(1, row+1);  // 注意范围为左闭右开, 所以 row 需要加 1
    int y = rd.Next(1, col+1); 

    if (map[x, y] != -1) {  // 不要重复放置雷, 那样雷的总数会少
        map[x, y] = -1;
        cnt++;
    }
}

接下来要访问整个棋盘, 数每个不是雷的格子周围的雷的数量, 代码:

1
2
3
4
5
6
7

for (int row = 1; row <= mapRow; row++) {  // 循环每行
    for (int col = 1; col <= mapColumn; col++) {  // 循环每列
        if (map[row, col] != -1) {  // 如果不是雷再计数
            // do something (见后文)
        }
    }
}

但我们要怎么遍历每个格子周围的 8 个格子?

其中一个方法是:

由于每个格子相邻的格子的横纵坐标都是当前坐标加减 1, 所以我们可以用这样两个一维数组:

1
2

int[] moveRow    = {  1,  1, 1, 0, -1, -1, -1,  0 };  // 加了一堆空格是为了便于理解
int[] moveColumn = { -1,  0, 1, 1,  1,  0, -1, -1 };

这样我们只要循环 i, 将当前的格子横纵坐标分别加上 moveRow[i] 和 moveColumn[i], 就能遍历一个格子周围所有的位置了, 代码:

1
2
3
4
5
6
7
8
9
10
11
12
13

int cnt = 0;  // 用来记录周围雷的数量
for (int i = 0; i < 8; i++) {
    int currRow = row + moveRow[i];  // 新的行数
    int currCol = col + moveColumn[i];  // 新的列数

    // 如果找到的位置不在地图中就跳过
    if (currRow < 1 || currRow > mapRow || currCol < 1 || currCol > mapColumn) {continue;}
    
    if (map[currRow, currCol] == -1) {  // 如果是雷就 +1
        cnt++;
    }
}
map[row, col] = cnt;

另一个方法不需要辅助数组, 再写一个二重循环, 判断一下不是本格就好:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

int cnt = 0;  // 用来记录周围雷的数量
for (int i = -1; i <= 1; i++) {
    for (int j = -1; j <= 1; j++) {
        int currRow = row + i;  // 新的行数
        int currCol = col + j;  // 新的列数
    }

    // 如果找到的位置不在地图中就跳过
    if (currRow < 1 || currRow > mapRow || currCol < 1 || currCol > mapColumn) {continue;}

    // 如果就是本格也跳过
    if (currRow == row && currCol == col) {continue;}

    if (map[currRow, currCol] == -1) {  // 如果是雷就 +1
        cnt++;
    }
}
map[row, col] = cnt;

最后把上面的代码组合起来, 加个输出, 完整代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

int mapRow = 10, mapColumn = 10, mineNum = 10;
int[,] map = new int[mapRow+1, mapColumn+1];

int[] moveRow    = { 1, 1, 1, 0, -1, -1, -1, 0 };
int[] moveColumn = { -1, 0, 1, 1, 1, 0, -1, -1 };


Random rd = new Random();

for (int cnt=1; cnt <= mineNum; ) {  // cnt 表示正在放第 cnt 个雷, 注意这后面没写 cnt++
    int x = rd.Next(1, mapRow+1);  // 注意范围为左闭右开, 所以 row 需要加 1
    int y = rd.Next(1, mapColumn+1); 

    if (map[x, y] != -1) {  // 不要重复放置雷, 那样雷的总数会少
        map[x, y] = -1;
        cnt++;
    }
}

for (int row = 1; row <= mapRow; row++) {  // 循环每行
    for (int col = 1; col <= mapColumn; col++) {  // 循环每列
        if (map[row, col] != -1) {  // 如果不是雷再计数
            int cnt = 0;  // 用来记录周围雷的数量
            for (int i = 0; i < 8; i++) {
                int currRow = row + moveRow[i];  // 新的行数
                int currCol = col + moveColumn[i];  // 新的列数

                // 如果找到的位置不在地图中就跳过
                if (currRow < 1 || currRow > mapRow || currCol < 1 || currCol > mapColumn) {continue;}
                
                if (map[currRow, currCol] == -1) {  // 如果是雷就 +1
                    cnt++;
                }
            }
            map[row, col] = cnt;
        }
    }
}

for (int i = 1; i <= mapRow; i++) {
    for (int j = 1; j <= mapColumn; j++) {
        if (map[i, j] == -1) {
            Console.Write("* ");  // 为了便于观察, 如果是雷就输出星号
        }
        else {
            Console.Write("{ 0 } ", map[i, j]);
        }
    }
    Console.WriteLine("");  // 输出空行
}

刚刚在我的电脑上产生的随机输出结果如下:

1
2
3
4
5
6
7
8
9
10

0  0  0  0  0  2  *  2  0  0  
0  0  0  1  1  3  *  2  1  1
0  0  0  1  *  2  1  1  1  *
0  0  0  1  1  1  0  0  2  2
1  2  2  2  1  0  0  0  1  *
*  2  *  *  1  0  1  1  2  1
1  2  2  2  1  0  1  *  1  0
0  0  0  0  0  0  1  1  1  0
0  0  0  0  0  0  0  0  1  1
0  0  0  0  0  0  0  0  1  *

再谈字符串

字符串也可以用下标进行访问, 但是不能用下标直接修改:

1
2
3

string str = "abcde";
Console.WriteLine(str[0]);  //正常运行
str[1] = 'c';  // 报错

字符串也有 Length 属性, 所以可以用 str.Length 访问：

1
2
3
4

string str = "abcde";
for (int i = 0; i < str.Length; i++) {
    Console.WriteLine(str[i]);
}

当然也可以用 foreach 语句循环遍历字符串:

1
2
3
4

string str = "abcde";
foreach(char c in str) {
    Console.WriteLine(c);
}

但大家可能有些疑问，为什么是 char 而不是 string c

因为字符串的本意就是一堆 “字符” 串起来, 也就是说, 字符串中的每一个元素应该是一个字符
char 就是表示字符的数据类型(英文character的缩写), 字符a 记为 'a'

因为 'a' (字符a)容易与 "a" (字符串a)混淆所以之前一直没有提过, 他们的区别就类似于int类型的 5 与 只有一个int类型的元素的数组 { 5 }, 是不一样的东西

例题 4-3 [洛谷B2124] 判断字符串是否为回文

输入一个字符串，输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。
如果字符串是回文，输出 yes 否则，输出 no

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

string str = Console.ReadLine();
int length = str.Length;

bool suc = true; 
for (int i = 0; i < length / 2; i++) {
    if (str[i] != str[length-i-1]) {
        suc = false;
        break;
    }
}

if (suc) {
    Console.WriteLine("yes");
}
else{
    Console.WriteLine("no");
}

练习

4-1 最高分与最低分之差

先读入 n , 下一行输入 n 个成绩，输出 n 个成绩中最高分数和最低分数的差。

4-2 [洛谷B2122] 单词翻转

小明同学写单词的时候喜欢反着写，比如 hello 他会写成 olleh
给出小明同学写的一个句子，请你将所有的单词复原。

输入

共一行，一个字符串表示句子，单词之间以空格分隔。

输出

每个单词一行

4-3 完善学生分数排名系统

接着完善一下学生分数排名的程序:

1. 本文给的代码只能处理整数, 改成能处理浮点数的
2. 对输入做一下判断, 例如: 如果输入的分数根本不能变为浮点数或者输入数字大于满分或者小于0, 就让它重新输入
3. 输出平均分数

本文于 2023.03.26 大修（近半重写）

因为 csp-s 考的太惨了，所以一直想着回头把前三题都AC了，结果一拖拖到现在才做完（

还有就是动态规划好难（wtcl）

题意

本题题意较复杂，建议直接去看原题（题目链接）。

总的来说，合法的括号序列一共分两类：

1. 包含型：$()$，$(A)$，$(S)$，$(AS)$，$(SA)$

2. 并列型： $AB$ ，$ASB$

显然合法的括号序列两端必然分别是左右括号，而且合法的括号序列最小长度为2。

初步分析

数据范围可知这题大概需要一个 $O(n^3)$ 的方法

这道题一看就像是区间DP。设状态 $f[i][j]$ 表示 $[i,j]$ 这段区间内的数量，由于上文已经证明看出“合法的括号序列两端必然分别是左右括号”，所以需要先确保 $i$ 对应位置可以为 (,即 a[i] == '(' || a[i] == '?'，对 $j$ 也同理，不满足的话 $f[i][j]$ 一律为 0。后文的讨论均基于 $i,j$ 满足要求的情况。

按照刚刚上面的分类进行讨论，记 $s[i][j]$ 表示 $[i:j]$ 能否完全由不超过 k 个连续的 * 或者 ? 组成，或者说 $s[i][j]$ 表示 $a[i][j]$ 能否构成题目中的 S。则可列出方程：

$$\left. \begin{array}{ l }{ (A):f [i] [j] += f[i+1][j-1] } \\{ (S):f[i][j] += 1, s[i+1][j-1]=true } \\\end{array} \right.$$

（放在逗号右面表示只有当满足这个条件时才计算）

$(AS)$ 只要枚举一下 S 就行，$p$ 为 A 的右端点（包含）：

$${ (AS):f[i][j] += \sum_{p=i+2}^{j-1}f[i][p],\space s[p+1][j-1]=true }$$

$(SA)$ 与 $(AS)$ 差不多，留作习题答案略。那么包含型的情况已经讨论完了。

下面是并列型的情况。在计算 $ASB$ 的贡献的时候，如果像我们刚刚那样设计状态就会列出错误的方程：

$$f[i][j]+=\sum_{p=i+1}^{j-2}\sum_{q=p+1}^{j-1} f[i][p]\times f[q][j],\space s[p+1][q-1]=true$$

这个式子即枚举 $A$ 的右端点 $p$ 和 $B$ 的左端点 $q$（均包含）来间接枚举 $S=a[p+1:q-1]$，从而转移 $ASB$，这里 S 能取空所以可以连 AB 的情况一起处理。

但是这样的转移方程为什么是错的呢，我们看下面这样的括号序列：

()()??()

有以下几种情况：

显然算重了（由于在计算子区间 $A$ 和 $B$ 的并列型情况时还会有重复，所以按这种错误方法算出的情况数不止上述 6 种）。

去重

如果每次在左边的 $A$ 只枚举包含型，不枚举并列型的结构，而 $B$ 包含型与并列型都枚举，这样每种拆法就只会数一次了。后文将这种拆法表示为 $FS?B$（$?$ 表示可有可无）。由于 $FS?B$ 没法再拆成其他的并列型，所以显然不会重复，下面简要证明不会遗漏：

一种并列型的 $A$ 总能表示为 $A = F+S'?+B'$，其中 $F$ 为包含型，$B'$ 任意，情况 $A+S?+B = F+S'?+B'S?B$，符合 $FS?B$，故能够被计数。

重新设计一下状态，用 $f[i][j]$ 表示该区间内包含型序列的数量，$g[i][j]$ 表示并列型序列的数量。

重新看一下原来的转移方程，你会发现 $(A)$，$(S)$ 的转移方程不需要改，$(AS)$ 的转移方程只是把后面的 $f[i][p]$ 改成 $f[i][p]+g[i][p]$ 即可。

仿照原来的思路，$ASB$ 的转移方程如下：

$$g[i][j] = \sum_{p=i+1}^{j-2}\sum_{q=p+1}^{j-1} f[i][p] \times (f[q][j]+g[q][j]),\space s[p+1][q-1] = true$$

代码如下（为了清晰直观，删去取模的过程）：

1
2
3
4
5
6

for(int p=i+1; p <= j-2; p++){
    for(int q=p+1; q <= j-1; q++){
        if(s[p+1][q-1] || q == p+1) g[i][j] += (ULL)f[i][p] * (f[q][j] + g[q][j]);
        else break;
    }
}

按这个思路写对了应该就能拿到 65 pts 了，现在离 AC 还差一个优化。

优化

复杂度瓶颈在 $ASB$ 的 $O(n^4)$ 上，所以观察 $ASB$ 的式子，此时先把 $i$ 和 $j$ 当做定值。

后面的 $f[i][p]$ 的值与 $q$ 无关，因此我们可以把 $f[i][p]$ 从最内层的求和里提出来。

$$\sum_{p=i+1}^{j-2}f[i][p]\times\sum_{q=p+1}^{j-1}(f[q][j]+g[q][j]),\space s[p+1][q-1] = true$$

只关注内层的循环，这时如何优化就明显一些了——前缀和。

我们设一个新数组 $h$：

$$h[p]=\sum_{t=i+2}^{p}f[t][j]+g[t][j]$$

若忽略 $s$ 的条件，最内层循环等于 $h[j-1] - h[p]$。

再考虑 $s$，由于最内层循环在递增的是 $p$ 而 $q$ 并不变化——作为条件的区间 $s$ 是左端点不动向右延伸的——我们可以预处理出每一个位置往后延伸的 * 或者 ? 的最长的长度，记为 $b[i]$，则从 $p+1$ 点最远能延伸到的下标为 $p+1+b[i]$。所以我们就可以在每次循环 $i$ 的时候预处理 $h$ 数组的值，用 $h[min(j, p+b[p+1]+1)] - h[p]$ 代替原来最内层的求和了。

因为 $l$ 递增，所以不用担心 $f[q][j]$、$f[q][j]$ 还没有求（这两个区间肯定比正在求的小）。

（其实建议预处理时直接处理出向后延伸到的最大下标，应该会方便一点，但我懒得改了）

最终代码（代码丑，请见谅）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

#include <algorithm>
#include <cstdio>

using namespace std;

constexpr int maxn = 550;
constexpr int MOD = 1'000'000'007;

using ull = unsigned long long;
using ll = long long;

int normal(ll x)
{
    int rst = x % MOD;
    if (rst < 0) rst += MOD;
    return rst;
}

// 计算模意义下可变个数的参数的和，用法： add(...)

template <typename T>
int add(T x)
{
    return normal(x);
}

template <typename T, typename... Ts>
int add(T x, Ts... args)
{
    return normal(x + add(args...));
}

int mul(int a, int b)
{
    return normal(ll(a) * ll(b));
}

int n, k;
char a[maxn];
int f[maxn][maxn];   // 包含型，后用 F 代替
int g[maxn][maxn];   // 并列型，后用 G 代替
bool s[maxn][maxn];  // a[i:j] 能否构成连续个数小于 k 的 *
int h[maxn], b[maxn];

int main()
{

    scanf("%d%d", &n, &k);
    scanf("%s", a + 1);

    for (int i = 1; i <= n; i++) {
        int j;
        for (j = i; j <= n && j - i + 1 <= k; j++) {
            if (a[j] == '*' || a[j] == '?')
                s[i][j] = true;
            else
                break;
        }
        b[i] = j - i;
    }

    for (int l = 2; l <= n; l++) {
        for (int i = 1; i + l - 1 <= n; i++) {
            int j = i + l - 1;

            // 合法的括号序列两端必然分别是左右括号
            if ((a[i] != '(' && a[i] != '?') || (a[j] != ')' && a[j] != '?')) continue;

            if (i + 1 == j) {  // 单独一对括号 ()
                f[i][j] = 1;
                continue;
            }

            if (s[i + 1][j - 1]) f[i][j] = 1;  // (S)

            f[i][j] = add(f[i][j], f[i + 1][j - 1], g[i + 1][j - 1]);  // (F) 或 (G), 对应 (A)

            for (int p = i + 1; p < j - 1; p++) {  // (SF) 或 (SG), 对应 (SA)
                if (s[i + 1][p])
                    f[i][j] = add(f[i][j], f[p + 1][j - 1], g[p + 1][j - 1]);
                else
                    break;
            }

            for (int p = j - 1; p > i + 1; p--) {  // (FS) 或 (GS), 对应 (AS)
                if (s[p][j - 1])
                    f[i][j] = add(f[i][j], f[i + 1][p - 1], g[i + 1][p - 1]);
                else
                    break;
            }

            // AB 或者 ASB

            h[i + 1] = 0;  // 前缀和优化
            for (int p = i + 2; p <= j; p++) {
                h[p] = add(h[p - 1], f[p][j], g[p][j]);
            }

            for (int p = i + 1; p <= j - 2; p++) {
                g[i][j] = add(g[i][j], normal(mul(f[i][p], add(h[min(j, p + b[p + 1] + 1)], -h[p]))));
            }
        }
    }

    printf("%d", add(f[1][n], g[1][n]));

    return 0;
}

本文主要由zbx1425大佬所写

再谈数据类型

数据类型是一个初学者不太容易搞懂的概念，所以我们还要再强调一下。
首先，C#中的每一个“值”都是有类型的。包括由我们直接写出的称为“字面量”的东西（如 123， “Hello World”），变量的内容，以及函数返回的结果。（注：“返回 xxx” 意思就是函数运行的结果是xxx）

• 1 - int: 不带小数点的数字是 int 类型的 “字面量”

• 1.0 - double: 带上小数点之后，它就成了一个 double 类型的 “字面量”
  请仔细注意这里的区别。例如 3 / 2 结果是 1，因为被除数和除数都是 int 所以执行了整数除法；但 3.0 / 2 由于被除数是 double 会执行浮点数除法，结果就是 1.5 了，这就是类型不同引发的差异，即使是对于直接给出的“字面量”也是同样。

• "1.0" - string: 双引号括起来的是 string 类型的 “字面量”，注意它和不带双引号的值 1.0 的类型与意义可完全不同！以及，（与Python不同）单引号括起来的是另一个没提过的类型，C# 中区分单双引号，只能用双引号表示 string，不要用错。

• Convert.ToInt32("3") - 一个 string 传入 Convert.ToInt32 函数，该函数返回 int 类型，所以它整体的结果是 int 类型的 3。

一个函数接收什么类型的值，与返回什么类型的值，是由其定义决定的。难道要一个个背？不用！SharpDevelop 提供了一个贴心小功能来让您快速了解这一关键信息。
在提示列表中查找函数时，或将鼠标指针放在代码中一个函数的名称上时，将会显示一个黄底的提示框，里面有形如这样的信息（此处以ToInt32为例）：

1

[↑] 1 of 19 [↓] public static int ToInt32(string value);

• 1 of 19: 表示该函数有19种用法，也就是说可以接受19种参数（用专业名词说叫“重载”）（想不到这么多吧，233，这个函数挺强大的，不仅是string，一大堆东西都能给它转换成int），此处显示了第一种。可以点击左右的上下箭头按钮来查看全部的用法。
• public static: 这俩咱现在不用管。
• int: 这个在 ToInt32 函数名之前的第一个单词，就代表了它的返回类型。在这个例子中，您就知道这个函数（在这种用法中）运行之后的结果一定是一个int整数。
• (string value): 括号里的是使用这个函数时要传入的参数。前一个单词是类型，后一个单词是名字，有多个时会用逗号分开显示。您在上节课的练习中把Console.ReadLine()读出来的string转换成int时，不就是在括号中传入了一个string类型的值－输入进来的文字么？

我们再来看一看下面这段代码。

1

Console.WriteLine(Convert.ToString(Convert.ToDouble(Console.ReadLine()) / 2));

这段代码看起来很长，对于初学可能相对难以理解，让我们一点一点来解释。

我们上次讲过嵌套函数的运行类似数学中的复合函数 $f(g(x))$ , 从最内层的函数开始运行, 然后把返回的数值代入到外面一层的函数中作为参数。

1. 首先是最内层的 Console.ReadLine() 运行，并把读入的一行字以 string 类型返回。如果输入的是 5，现在代码就变成了：

1

Console.WriteLine(Convert.ToString(Convert.ToDouble("5") / 2));

2. Convert.ToDouble(“5”) 运行，将 “5” 转换成 double 的 5.0 并返回。

1

Console.WriteLine(Convert.ToString(5.0 / 2));

3. 由于一边是 double 一边是 int，运行了浮点数除法，结果是 double 的 2.5。随后 2.5 被Convert.ToString 转换成 string 的 “2.5”，然后被 Console.WriteLine 写到窗口中。
4. 其实在这个例子中，如果去掉 Convert.ToString，也照样能够输出。这是因为 Console.WriteLine 也是有一大堆“用法”，不仅接受 string 也接受 double，您不妨在那个“用法列表”里找一找。

显然，如果不把值放在一个变量里，那一行代码执行完了之后值就没了。变量就是一种储存值的容器。正如上一节课中介绍的，在C#中，一个变量只能储存一种特定类型的值。

比如我们需要以 double 类型保存下来输入的内容以备以后再用, 那就把上面的代码改成：

1
2

double a = Convert.ToDouble(Console.ReadLine());
Console.WriteLine(Convert.ToString(a / 2));

new 运算符

编程中要处理各种各样的数据, 要是只有我们学过的 int string double 那几种类型可能会十分麻烦, 例如要是用 int 来保存当前时间的话 就需要 6 个 int 类型的变量来分别保存年月日时分秒。因此 C# 里除了我们已经用到的 string int double 之外，还提供了很多其他的类型。

那么问题来了。在使用 string int double 的时候，除了从函数中取得（如Console.ReadLine()），我们想要用一个值的时候都可以用字面量的形式写出来。比如我们想要整数1就可以直接写1，想要字符串Hello就直接"Hello"。但是字面量就只能表示这些最基础的类型了。
假如我们想要一个表示 1919年8月10日11:45:14 的时间（在C#中有个专门的类型用来表示和处理时间，叫DateTime），就没有办法用字面量写出来了，怎么办呢？

大佬们自然给我们想好了。这就是"new 运算符"。new DateTime(1919, 8, 10, 11, 45, 14) 就会给我们一个我们想要的值了。

1
2

DateTime a = new DateTime(1919, ...); // 既可以存在变量里（此处省略后面的数字）
Console.WriteLine(Convert.ToString(new DateTime(1919, ...))); // 也可以像之前的字面量一样直接用

这个用法是不是很像在用一个函数？实际上它就是一个特殊的函数（叫“构造函数”），必须要前面配着"new"来用，而且会给你一个该类型的值。和函数一样，你也可以使用那个小黄框来看它的各种用法。

不过为什么要用这些别的类型呢？因为微软在这些类型内部封装了一些便利的功能，来帮助我们完成一些与它们有关的操作。专事专用，用日期专用的类型来处理日期就会方便很多。例如，如果我们要算两个日期之间差几天，如果你用 int 来表示每个的年月日，自己来算日期，就得自己处理进位借位（进到下个月，退到上个月）、每个月多少天、是不是闰年等麻烦事。但是微软的大佬们已经给我们预先准备好了日期减日期的运算程序。我们可以直接用：

1
2
3
4
5
6
7

DateTime date1 = new DateTime(2021, 12, 5, 0, 0, 0); // 2021-12-5
DateTime date2 = new DateTime(2022, 6, 7, 0, 0, 0); // 2022-6-7
TimeSpan delta = date2 - date1;
// 这里用了微软在C#语言里面提前帮我们写好的 “日期 - 日期” 计算，它能自动处理好日期计算里的各种问题！完全不用咱自己动脑子
// TimeSpan 又是个新类型，它用来专门表示一个“时间差”。不需要记，这里只是拿来举例子
// 显然 日期 - 日期 得到一个“时间差”类型的结果，挺合理的
Console.WriteLine(Convert.ToString(delta)); // 而且ToString也支持TimeSpan类型

当然，不是所有问题都有提前做好的解决程序（不然咱还学编程干嘛），不过要是有为啥不用呢？多方便。

成员

接下来我们深入地讲一下上一节课讲到的成员访问（“.”）。
为了简便（以及与专有名词接轨）起见，我们从现在开始将某一个类型的值称为“对象”。对象这个词中文上可能相对不太好理解, 对象的英文是 object, 作为编程术语时翻译为对象, 它也有 “宾语”, "物体"的意思, 换句话说, 我们生活中能见到的非抽象的东西都可以叫对象。

如，上面这个例子中，date1 变量里储存了一个 DateTime 类型的对象。把它理解成“一个东西”即可。
成员可以理解为是一个对象“里面的”内容，可以使用"."来获得或使用。例如：Year Month Day 都是 DateTime 的成员。在上面一个例子中，date1.Year 就会返回 int 类型的 2021，它是这个日期的“年”成份。

有些成员是“非静态”的。别被这个不知所云的名词吓倒，它的意思是，这个内容是和一个特定的对象相关的，而不是和这个类型的总体泛泛地相关的。也就是说，非静态的不是对于每个对象都一样的。而“静态”（就是我们之前看到的 static 修饰符）与之正相反，是一种总体的东西，与整个类型有关，和每个单独的对象没有关系。

好像有些不太好理解，我们举个例子。例如，刚才提到的Year就是DateTime 的非静态成员，因为不同的日期的值的年份可能不同。或者再举个例子，如果我们有一个“学生”类型，那么“班级”就是它的非静态成员，因为不同的学生可能在不同的班；但是“腿数”就可能是个静态成员，因为所有学生都是两条腿——当然在设计的时候把它做成非静态的也行，不过不太有必要。

如果要用一个非静态的成员，在一个值的后面加".“就可以访问到它了。例如上面的 date1.Year 就是获取了date1 这个对象 的 Year 成员。如果要用一个静态的成员，在类型名的后面加”."即可。如 int.MaxValue 就获取到了 int 类型所能表示的最大数值。您也想必很容易理解，“能表示的最大数值”这种东西一般是“静态”的。

您甚至可以套好几层的成员访问。用上面那个学生的例子就是：“小明.班.学生人数” 获得小明这个学生所在的班的学生人数。

成员不仅可以是值，还可以是函数。例如我们一直在用的 Console.WriteLine 就是 Console 类型的一个静态成员函数（您是直接用"Console"这个类型名，而不是在 new 一个 Console 对象来用的）。

您可能会说：不对呀，输出内容不是和特定的窗口相关的吗，为什么它是静态的呢？这是因为Windows系统规定每个程序只能有一个控制台窗口，所以既然只有一个为了方便起见就干脆搞成静态的了。

您应该已经感受到值和函数的区别还是挺大的，值可以直接用，但是函数就得加()来调用，有时候还得在括号里写参数。如何区分呢？

您可能已经注意到，当您打出一个"."字时，SharpDevelop将自动弹出提示列表，里面就会列出它所有成员的名字。每个名字的左侧都有一个图标，形如“蓝色方块”和“手拿着表格”的分别是“成员变量”和“属性”，不用太计较它们的区别，它们都可以直接当作一个值来用，例如刚才的date1.Year。形如“紫色方块”的就是函数，它们要用括号来调用，例如Console.WriteLine(...)。

善用自动提示！SharpDevelop的提示功能与小黄框可以显示各个成员的名称、类型和用法，您几乎不用背诵任何内容。

什么是 “null”？

在开始讲这一节之前，我们先来引入一个有趣的东西：随机数发生器。
这同样也是个类型——Random，一个 Random 的对象有一个叫 Next 的非静态成员函数，使用时需提供两个 int 类型参数分别表示最小和最大值（左闭右开），反复调用即可从里面不断取出不同的数。用来做猜数游戏想必很有趣。还是那句话，只是为了举例子，不用背。

假设我们想得到一个1~50的随机数，写了这样的代码：

1
2

Random rand;
Console.WriteLine(rand.Next(1, 51)); // 左开右闭所以右边是51

运行一下，报错了！出现了"NullReferenceException"（空引用错误）。这是为什么呢？

原来，Random rand 这样声明变量，只是创建了一个叫 rand 的，可以存储 Random 对象的“盒子”。rand的里面是空的，并没有把一个实际的 Random 随机数生成器对象“装”到里面。

当我们在 rand.Next 的时候，我们要把这个生成器从"rand"这个"盒子"拿出来让它给我们生成个随机数－－但rand里现在是空的，并没有一个生成器被装在里面。所以自然出现了问题。

那我们应该怎么做呢？我们要用某种方法获得一个生成器的对象（值），然后把它装到 rand 这个“盒子”里。怎么获得呢？还记得 new 运算符么？

1
2
3

Random rand;
rand = new Random(); // 用 new 运算符搞出一个Random对象来（Random类型构造函数不需参数）
Console.WriteLine(rand.Next(1, 51)); // 现在rand已经“有对象”了，可以正常用了

接下来介绍"null"。"null"是个特殊的值，表示“没有值（没有对象）”的这么一个状态。例如，最开始的时候，rand里没有对象（没有值），也可以说“rand的值是null”。
你还可以给变量赋值为null。这代表着把里面已经有的对象（如果有）给扔掉。

1
2
3

Random rand = new Random(); // 搞出来一个生成器搁进去
rand = null; // 又给扔了
Console.WriteLine(rand.Next(1, 51)); // 又会报错了，因为已经给扔了，现在又没了

类似的，如果想知道一个变量里面有没有正在存着一个值，可以使用 rand == null和rand != null 判断。

特殊的是，内置的 int 和 double （以及部分别的，如DateTime）是“值类型”。与刚刚的 random 的区别在于，一个值类型的变量（如int a）一被创建就会自动地装有一个对象（一般会是0）。可以把它修改成别的值（a = ...），但是不能扔掉（a = null 在编译时就会报错）。所以您永远都不会担心自己 int 类型的变量会是 null 。
相反的，大多数其他类型就都是可以为"null"的了（这种类型的学名叫“引用类型”），所以用的时候一定要注意。如果您不太拿得准，最好在声明变量的时候就用"new"搞个值出来赋给它。

string 是个有趣的例子，因为它也是个“引用类型”。也就是说，“” 是个空字符串， 而 null 则是“没有字符串”。

关于这个编程上有一个相关的非常形象的笑话：卫生间里挂厕纸的那个挂钩，字符串 "abc" 是挂钩上挂着一卷纸；"" 是挂钩上没纸了，但是还挂着那个硬质壳的芯；null 则是干脆钩上啥也没了。

这也是要注意的一点。当访问 string 的成员时（string 有个叫 Length 的非静态属性，代表它的长度）：

1
2
3

string a = "abc"; Console.WriteLine(a.Length); // 输出 3
string b = ""; Console.WriteLine(b.Length); // 输出 0
string c; Console.WriteLine(c.Length); // 不会输出0 － 程序会报错崩溃！

因为c是null，所以试图访问c.Length会直接导致"NullReferenceException"错误。
当然，日常使用中我们不太会经常遇到"null"的string，所以不用过于担心；但您还是需要了解这种现象。

循环语句

while 循环

假设我们要写一个程序永远不停的输出 hello world (直到你关掉这个程序), 代码如下:

1
2
3

while (true) {
 Console.WriteLine("hello world");    
}

其中小括号里的为条件, 大括号里的(即这个代码块)为参与循环的部分
在进入循环之前会先判断括号里的条件，如果为 true 才执行，每次执行完大括号里的内容会再次判断括号里的条件，如果为 true 则再次执行大括号里的内容，循环往复直到括号里的条件为 false

因为上面的例子中括号里恒为 true 所以这个循环会永远进行下去

再举一个不是死循环的例子：

1
2
3
4
5

int a = 5;
while (a < 10) {
    Console.WriteLine("a 的值: {0}", a);
    a++;  // 自增运算符, 相当于 a = a + 1;
}

大家可以预测一下输出的结果。

1
2
3
4
5

a 的值: 5
a 的值: 6
a 的值: 7
a 的值: 8
a 的值: 9

猜数游戏

在这里先介绍一下如何生成随机数：

1
2

Random rd = new Random();  // 如果要生成多组随机数 这行也只需要在最开始写一遍
int a = rd.Next();  // Next()函数返回下一个随机数

这么写具体的原理会在下一节进行解释

如果要生成指定范围内的随机数应该写为：

1

rd.Next(5, 11);  // 左闭右开，所以此处为 [5,11) 范围内的随机数，并不包括 11

这样我们就可以写一个猜数游戏了：生成 [1,100] 内的一个随机数，让玩家来猜这个数的大小，提示玩家猜测的数是偏大还是偏小，直到玩家猜中

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Random rd = new Random();
int a = rd.Next(1, 101);

Console.WriteLine("输入你猜测的数字:");

int num = Convert.ToInt32(Console.ReadLine());

while(num != a) {
    if (num < a) {
        Console.WriteLine("不对不对, 太小了");
    }
    else {
        Console.WriteLine("不对不对, 太大了");
    }
    Console.WriteLine("再猜一次吧:");
    num = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine("恭喜你猜对了!");

例题 2-1 竞选社长

假设电子电路社要竞选下一届社长，有两名候选人分别是A和B，社团每名同学必须并且只能投一票，最终得票多的人为社长.

输入包含若干行的字符，每行仅包含A或B，输入以字符0结束。（原题为一行字符序列）