ganyuo

Qt 学习笔记

Sat, 11 Mar 2023 00:00:00 GMT

先说两句#

最近偷懒了很久没有学习，对于自己的懒惰实在是看不下了，所以决定随便学点什么。但是最近没什么学习的方向，想起之前学过一点点Qt，但是没有学完，所有打算先把Qt学完，说不定以后能用上，随便记录一下学习笔记。我自己是一个自制力比较差的人，但是有点强迫症，如果了笔记没写完，会非常不舒服，所有以后以后把学的东西都记一下笔记，能一定程度上约束一下自己。突然想起之前写的shell脚本笔记还有sed命令还没学完，emmm…下次再补。

Qt简介#

Qt是一个跨平台的C++开发库，主要用来开发图形用户界面程序。Qt还存在Python、Ruby、Perl等脚本语言的绑定，也就是说可以使用脚本语言开发基于 Qt 的程序。开源社区就是这样，好东西就会被派生扩展，到处使用，越来越壮大。

Qt支持的操作系统有很多，例如通用操作系统Windows、Linux、Unix，智能手机系统Android、iOS、WinPhone，嵌入式系统QNX、VxWorks等等。

上面是从C语言中文网上抄的Qt简介，附上Qt的官网，感兴趣的小伙伴可以去看看。

Qt包含很多C++的类，但是头文件代码里的注释基本没有，2333…，所以只能去看Qt官网上的文档：https://doc.qt.io/qt-5/classes.html，里面有所有类的说明。因为类太多了，所以后面关于类的成员函数就不解析了，小伙伴们有不清楚的地方可以去官网上查。

环境搭建#

我自己是在linuxmint系统下用VScode搭建的，具体参考这篇博客，其他系统下搭建环境的小伙伴也可以参考一下。

pro文件配置#

pro文件只要用于配置Qt项目的编译，具体配置方式抄参考了一下大佬的这篇文章

常用配置项#

注释 : 注释是从一行的#开始，到这一行的结束。
QT += : 这个是添加QT项目需要的模块的，若项目中要排除某个模块，也可用QT -= 配置项。
TEMPLATE = : 这个配置项确定qmake为这个应用程序生成哪种makefile 。有下面五种形式可供选择：
- app : 建立一个应用程序的makefile，这个是默认值，若模块项未指定，将默认使用此项；
- lib : 建立一个库的makefile；
- vcapp : 建立一个应用程序的VisualStudio项目文件；
- vclib : 建立一个库的VisualStudio项目文件；
- subdirs : 这是一个特殊的模板，可以创建一个可进入特定目录并为一个项目文件生成makefile，此makfile可以调用make；
TARGET = : 这个配置项用来指定最后生成的目标应用程序的名称。
CONFIG += : 用来告诉qmake关于应用程序的配置信息，使用+=表示在现有的配置上添加，这样会更安全。比如，CONFIG += qt warn_on release 其具体的意义为：
- qt : 告诉qmake此程序是使用qt来连编的。即qmake在连接、为编译添加所需包含路径时会考虑qt的库；
- warn_on : 告诉qmake要将编译器设置为输出警告信息形式；
- release : 告诉qmake应用程序必须被连编为一个可发布的应用程序。开发过程中，也可以使用debug；
UIC_DIR += : 用来指定uic命令，将.ui文件转化为ui_*.h文件存放的目录。
RCC_DIR += : 用来指定rcc命令，将.qrc文件转换成qrc_*.h文件存放的目录。
MOC_DIR += : 用来指定moc命令，将含有Q_OBJECT的头文件转换成标准.h文件存放的目录。
OBJECTS_DIR += : 用来指定目标文件obj的存放目录。
DEPENDPATH += : 用来指定工程的依赖路径。
INCLUDEPATH += : 用来指定工程所需要的头文件。
CODECFORSRC += : 用来指定源文件的编码格式。
FORMS += : 用来指定工程中的ui文件。
HEADERS += : 用来指定工程中所包含的头文件。
SOURCES += : 用来指定工程中包含的源文件。
RESOURCES += : 用来指定工程中所包含的资源文件。
LIBS += : 用来指定引入的lib文件的路径，一般会在前面加下参数-L，根据不同的版本可以分为两种形式：
Terminal window
```
1
Release: LIBS += -L folder_Path # release版本引入的lib文件
2
Debug: LIBS += -L folder_Path   # debug版本引入的lib文件
```
DEFINES += : 用来定义编译选项。
DESTDIR += : 用来指定目标的生成路径。
跨平台处理信息也要写在pro文件中。其示例如下：
Terminal window
```
1
win32
2
{
3
    ....
4
}
5

6
unix
7
{
8
    ...
9
}
```

pro文件样例#

下面是大佬给的一个pro文件样例：

Terminal window展开收起

1
# 添加QT依赖的库
2
QT += gui
3
QT += core xml network multimedia serialport
4
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
5

6
# 添加c11配置支持
7
CONFIG += c++11
8
# 输出文件的名称
9
TARGET = YouAppName
10
# 配置控制台输出
11
CONFIG += console
12
# 输出类型application
13
TEMPLATE = app
14

15
# 源文件
16
SOURCES += main.cpp \
17
    appconfig.cpp \
18
    opendoorthread.cpp \
19
    TestProject/testform.cpp \
20
    TestProject/common.pb.cpp \
21
    TestProject/goods_req.pb.cpp \
22
    TestProject/goods_resp.pb.cpp
23

24
# 头文件
25
HEADERS += \
26
    appconfig.h \
27
    opendoorthread.h \
28
    TestProject/testform.h \
29
    TestProject/common.pb.h \
30
    TestProject/goods_req.pb.h \
31
    TestProject/goods_resp.pb.h
32

33
# 配置debug和release
34
CONFIG +=debug_and_release
35
CONFIG(debug,debug|release){
36
DESTDIR += $$PWD/debug
37
LIBS += -L$$PWD/debug/ -lThorModel
38
LIBS += -L$$PWD/debug/ -lThorUtil
39
LIBS += -L$$PWD/debug/ -lThorBLL
40
LIBS += -L$$PWD/debug/ -lThorHardwareUtil
41
LIBS += -L$$PWD/debug/ -lprotobufd
42
LIBS += -L$$PWD/debug/ -lprotobuf-lited
43
LIBS += -L$$PWD/debug/ -lopencv_core2410d
44
LIBS += -L$$PWD/debug/ -lopencv_highgui2410d
45
LIBS += -L$$PWD/debug/ -lopencv_imgproc2410d
46
LIBS += -L$$PWD/debug/ -lQtActionDetectd
47
}else{
48
}
49

50
# 需要的头文件
51
INCLUDEPATH += $$PWD/AllDLL/include
52
INCLUDEPATH += $$PWD/debug/3rdparty/opencv-2.4.10/include \
53
            $$PWD/debug/3rdparty/opencv-2.4.10/include/opencv \
54
            $$PWD/debug/3rdparty/opencv-2.4.10/include/opencv2
55
# ui
56
FORMS += \
57
    TestProject/testform.ui

展开收起

GUI#

Qt的很多GUI控件都是继承自QWidget，所以使用Qt的GUI一般都需要加上widgets和gui这两个库，pro项目文件样例如下：

Terminal window

1
# 添加widgets和gui库
2
QT += widgets gui
3

4
# 把main.cpp加到项目的代码列表里
5
SOURCES += \
6
    main.cpp

QWidget#

QWidget是Qt的窗口类，下面是一段样例代码：

1
#include <QApplication> /* 应用程序抽象类 */
2
#include <QWidget>  /* 窗口类 */
3

4
int main(int argc, char *argv[])
5
{
6
    QApplication app(argc, argv); /* 创建一个Qt应用 */
7

8
    QWidget widget; /* 构造一个窗口 */
9
    widget.setWindowTitle("Hello World"); /* 设置窗口标题 */
10
    widget.show(); /* 显示窗口 */
11

12
    return app.exec(); /* exec():进入消息循环 */
13
}

上面的代码中，创建了一个标题是Hello World的窗口。执行app.exec();后，会进入一个处理消息的死循环，app会捕获系统消息，并传递给widget窗口。这就是鼠标点击后能拖动窗口的原因，app将鼠标的点击、移动等消息传递给了widget，widget作出了对应的响应，窗口移动了位置。

控件#

Qt里有很多控件，大部分都是继承自Qwidget，所以控件也可以看作是一个窗口，这里列举一些常用的控件(抄大佬的这篇博客)：

控件	类名	描述
标签	QLabel	显示一个文本或图像。
按钮	QPushButton	用户可以点击的一个按钮，用来触发某个操作。
输入框	QLineEdit	用户可以在其中输入文本的一个输入框。
复选框	QCheckBox	用户可以勾选或取消的一个复选框。
单选按钮	QRadioButton	用户可以选择其中一个选项的一组单选按钮。
数字微调框	QSpinBox	用于选择一个数值的微调框。
滑动条	QSlider	用户可以通过滑动来选择数值的一个滑动条。
列表框	QListWidget	用于显示一组列表项的一个列表框。
组合框	QComboBox	类似于下拉菜单的一个组合框，用户可以选择其中一个选项。
多行文本框	QTextEdit	用户可以在其中编辑多行文本的一个文本编辑框。
日期和时间编辑框	QDateTimeEdit	用于选择日期和时间的一个日期和时间编辑框。

由于控件种类太多了，这里只介绍一下按钮QPushButton和输入框QLineEdit这两种控件，其他控件的很多性质和接口都比较相似，小伙伴们可以自己尝试，我就偷懒不写了。

按钮-QPushButton#

下面是一个在窗口中添加一个按钮的样例：

1
#include <QApplication> /* 应用程序抽象类 */
2
#include <QWidget>  /* 窗口类 */
3
#include <QPushButton> /* 按钮类 */
4

5
int main(int argc, char *argv[])
6
{
7
    QApplication app(argc, argv);
8

9
    QWidget widget; /* 构造一个窗口 */
10
    widget.show(); /* 显示窗口 */
11

12
    QPushButton button; /* 创建一个按钮对象 */
13
    button.setText("Button"); /* 设置按钮显示的文本 */
14
    button.setParent(&widget); /* 设置按钮的父窗口 */
15
    button.show(); /* 显示按钮 */
16

17
    return app.exec(); /* exec():进入消息循环 */
18
}

展开收起

上面的代码会创建一个窗口，窗口中包含一个按钮。在Qt中，QPushButton是QWidget的子类，所以按钮也可以看作是一个窗口。

Qt里的窗口可以存在父子关系，上面的代码中，button.setParent(&widget);的作用是将button按钮的父窗口设置成widget，设置后button按钮才会显示在widget窗口里面；如果不设置，button按钮会显示成一个独立的窗口，与widget窗口同级。

一个窗口在执行show()成员函数时，会将已经添加的子窗口也一起显示，如果是子窗口是在父窗口执行show()之后添加的，则子窗口不会显示，子窗口也需要执行show()才能显示出来。比如，去掉上面代码中的button.show()之后，虽然之后将button按钮添加到了父窗口widget里，但是widget窗口里的button按钮不显示。如果在widget窗口执行show()之前，将button按钮添加到了父窗口widget里，也就是在widget.show()之前执行button.setParent(&widget)，则即使button按钮不执行show()，也会在父窗口widget执行show()的时候一起显示出来。

输入框-QLineEdit#

下面是一个输入框的样例代码：

1
#include <QApplication> /* 应用程序抽象类 */
2
#include <QWidget>      /* 窗口类 */
3
#include <QLineEdit>    /* 输入框 */
4
#include <QVBoxLayout>
5
#include <QCompleter>
6

7
int main(int argc, char *argv[])
8
{
9
    QApplication app(argc, argv);
10
    QWidget widget; /* 构造一个窗口 */
11

12
    /* 添加两个输入框 */
13
    QLineEdit name_input, password_input;
14
    QVBoxLayout layout(&widget);
15
    layout.addWidget(&name_input);
16
    layout.addWidget(&password_input);
17

18
    QCompleter completer(QStringList() << "abc" << "aaa" << "123");
19
    completer.setFilterMode(Qt::MatchContains);
20
    name_input.setCompleter(&completer); /* 设置输入匹配提示 */
21
    name_input.setPlaceholderText("请用户名"); /* 设置输入提示 */
22

23
    password_input.setEchoMode(QLineEdit::Password); /* 设置回显模式为密码模式 */
24
    password_input.setPlaceholderText("请输入密码"); /* 设置输入提示 */
25

26
    widget.show(); /* 显示窗口 */
27
    return app.exec(); /* exec():进入消息循环 */
28
}

展开收起

上面的代码向窗口中添加了两个输入框，一个用来输入用户名，一个用来输入密码。用户名输入框设置了一个completer，可以将输入的字符串与completer的字符串列表进行匹配，显示匹配成功的字符串。密码输入框设置了设置回显模式为密码模式，可以将输入的字符显示为●。

坐标体系#

Qt里的Qwidget可以使用setGeometry()来设置控件的位置坐标，位置坐标是相对与父窗口的左上角计算的，下面是一个例子：

1
    QWidget widget;
2
    QPushButton button;
3
    button.setText("Button");
4
    button.setParent(&widget);
5
    /* 设置button相对父窗口的坐标ax,ay，以及button的宽度aw和高度ah */
6
    button.setGeometry(30, 30, 200, 100);

上面的例子中，setGeometry()有4个参数，前两个参数是button相对父窗口的坐标ax，ay，后面两个是button的宽度和高度aw，ah。

layout#

当一个窗口里控件很多时，使用setGeometry()来设置很麻烦，而且无法随着窗口的大小变化而调整。使用layout(布局)就可以很方便的解决这个问题，他们负责一组控件的几何管理。上面输入框-QLineEdit里的样例代码，使用的QVBoxLayout就是一种layout，可以将控件在垂直方向上排列，使得name_input输入框在password_input输入框上面，如果不使用layout，则两个输入框会重叠在一起。(以下内容大部分抄的大佬的这篇博客)

简述#

Qt布局系统提供了一种简单而强大的方法，可以在控件内自动排列子控件，以确保它们充分利用可用空间。Qt包含一组布局管理类，用于描述控件在应用程序用户界面中的布局方式。当控件的可用空间发生变化时，这些layout会自动定位和调整控件的大小，确保它们的排列一致并且用户界面作为一个整体仍然可用。

所有QWidget子类都可以使用layout来管理它们的子类。QWidget::setLayout()函数可以为一个控件设置layout。当以这种方式在窗口上设置layout时，它负责以下任务：

布置子控件。
最高层窗口可感知的默认大小。
最高层窗口可感知的最小大小。
调整大小的处理。
当内容改变的时候自动更新：
- 字体大小、文本或者子控件的其它内容。
- 隐藏或者显示子控件。
- 移除一些子控件。

常用layout#

为控件提供良好布局的最简单方法是使用Qt内置的布局管理器：QHBoxLayout、QVBoxLayout、QGridLayout和QFormLayout。这些类从QLayout继承，而QLayout又从QObject（而不是QWidget）派生。他们负责一组控件的几何管理。要创建更复杂的布局，可以将布局管理器相互嵌套。

QHBoxLayout：从左到右在水平行中布置控件。
QVBoxLayout：在垂直列中从上到下布置控件。
QGridLayout：在二维网格中布置控件，控件可以占用多个单元格。
QFormLayout：把控件按照标签-输入框的形式排列在两列。

为layout添加控件#

将控件添加到一个layout时，布局过程如下：

所有控件最初将根据它们的QWidget::sizePolicy()和QWidget::sizeHint()分配一定数量的空间。
如果任何控件设置了拉伸系数，并且其值大于零，那么它们将按其拉伸因子的比例分配空间（如下伸展因素所述）。
如果任何控件的拉伸系数设置为零，它们只会在没有其他控件需要空间的情况下获得更多空间。其中，空间首先分配给具有扩展大小策略的控件。
任何控件被分配的空间的大小如果小于它们的最小大小（如果未指定最小尺寸，则为最小尺寸提示），它们就会被按它们所需要的最小大小分配空间。（如果控件的伸展因素是它们的决定因素，它们不必有最小大小或者最小大小的提示。）
任何控件被分配的空间的大小如果大于它们的最大大小，它们就会被按它们所需要的最大大小分配空间。（如果控件的伸展因素是它们的决定因素，它们不必有最大大小。）

伸展因素#

控件通常是在没有伸展因素设置的情况下被生成的。当它们被布置到一个layout中时，控件会被根据它们的QWidget::sizePolicy()或者它们的最小大小的提示中大的那一个分配给整个空间的一部分。伸展因素是用来根据控件互相的比例来改变它们所被分配的空间。

如果使用一个QHBoxLayout来布置没有伸展参数设置的三个控件，则我们就会得到像下面这样的布局：

如果我们给每个控件设置一个伸展因素，它们就会被按比例布置（但是不能小于最小大小的提示），以下是按1:3<2设置的>：

简单的demo#

布局中常用的方法有addWidget()和addLayout()，addWidget()方法用于向layout中加入需要布局的控件，addLayout()方法用于向layout中加入子布局。

1
void addWidget(
2
    QWidget *widget, // 需要插入的控件对象
3
    int fromRow,     // 插入的行
4
    int fromColumn,  // 插入的列
5
    int rowSpan,     // 占用的行
6
    int columnSpan,  // 占用的列数
7
    Qt::Alignment alignment = Qt::Alignment // 各个控件的对齐方式
8
);
9

10
void addLayout(
11
    QLayout *layout, // 需要插入的子布局对象
12
    int row,         // 插入的起始行
13
    int column,      // 插入的起始列
14
    int rowSpan,     // 占用的行数
15
    int columnSpan,  // 占用的列数
16
    Qt::Alignment alignment = Qt::Alignment // 指定的对齐方式
17
);

展开收起

下面是一个样例：

1
#include <QApplication>
2
#include <QWidget>
3
#include <QPushButton>
4
#include <QLineEdit>
5
#include <QLabel>
6

7
#include <QVBoxLayout> /* 垂直布局 */
8
#include <QHBoxLayout> /* 水平布局 */
9
#include <QGridLayout> /* 格子布局 */
10

11
int main(int argc, char *argv[])
12
{
13
    QApplication app(argc, argv);
14
    QWidget widget;
15

16
    QGridLayout layout;            // 创建格子布局
17
    layout.setRowStretch(0, 1);    // 设置第0行的拉伸系数
18
    layout.setColumnStretch(0, 1); // 设置第0列的拉伸系数
19

20
    /* 向layout中添加控件 */
21
    layout.addWidget(new QLabel("用户名："), 1, 1);
22
    layout.addWidget(new QLineEdit(), 1, 2);
23
    layout.addWidget(new QLabel("密码："), 2, 1);
24
    layout.addWidget(new QLineEdit(), 2, 2);
25

26
    /* 向layout中添加子布局 */
27
    QHBoxLayout hbox;
28
    hbox.addStretch(1);  // 添加伸缩量
29
    hbox.addWidget(new QPushButton("登录"));
30
    layout.addLayout(&hbox, 3, 1, 1, 2);
31

32
    layout.setRowStretch(4, 1);    // 设置最后一行的拉伸系数
33
    layout.setColumnStretch(3, 1); // 设置最后一列的拉伸系数
34

35
    widget.setLayout(&layout); // 给窗口设置layout
36
    widget.show();
37
    return app.exec();
38
}

展开收起

主窗口#

抄了大佬的这篇博客。

主窗口QMainWindow是一个为用户提供主窗口程序的类，包含一个菜单栏（menu bar）、多个工具栏(tool bars)、多个浮动窗口(dock widgets)、一个状态栏(status bar)及一个中心区域(central widget)，主窗口是许多应用程序的基础，如文本编辑器，图片编辑器等。

下面是一个使用QMainWindow的样例：

1
#include <QApplication>
2
#include <QMainWindow>
3
#include <QMenuBar>
4
#include <QMenu>
5
#include <QAction>
6
#include <QObject>
7
#include <QToolBar>
8
#include <QStatusBar>
9
#include <QDockWidget>
10
#include <QLabel>
11
#include <QGridLayout>
12
#include <QLineEdit>
13
#include <QSystemTrayIcon>
14
#include <QVBoxLayout>
15

16
int main(int argc, char *argv[])
17
{
18
    QApplication app(argc, argv);
19

20
    QMainWindow main_win;
21
    main_win.resize(600, 400);
22

23
    /* 菜单栏 */
24
    QMenuBar *meun_bar = main_win.menuBar(); /* 获取主窗口的菜单栏 */
25
    QMenu *file_menu = meun_bar->addMenu("&file"); /* 在菜单栏里添加一个file菜单 */
26
    QMenu *edit_menu = meun_bar->addMenu("&edit"); /* 再添加一个edit菜单 */
27
    QAction *open_action = file_menu->addAction("&open"); /* 向file菜单里添加Action */
28
    QAction *save_action = file_menu->addAction("&save");
29
    file_menu->addSeparator();  /* 向file菜单里添加分割线 */
30
    QAction *exit_action = file_menu->addAction("&exit");
31
    /* 将exit Action的触发信号，连接到主窗口的关闭槽函数，实现点击exit后关闭主窗口 */
32
    QObject::connect(exit_action, SIGNAL(triggered(bool)), &main_win, SLOT(close()));
33
    exit_action->setToolTip("close window");
34

35
    /* 工具栏 */
36
    QToolBar *tool_bar = main_win.addToolBar("tool_bar"); /* 向主窗口添加工具栏 */
37
    tool_bar->addAction(open_action); /* 向工具栏中添加Action */
38
    tool_bar->addAction(save_action);
39
    tool_bar->addAction(exit_action);
40
    tool_bar->setAllowedAreas(Qt::AllToolBarAreas); /* 设置可停靠区域 */
41
    tool_bar->setFloatable(true); /* 设置是否可以浮动 */
42

43
    /* 状态栏 */
44
    QStatusBar *status_bar = main_win.statusBar();  /* 获取主窗口的状态栏 */
45
    QLabel *status_label = new QLabel("main window running...");
46
    status_bar->addWidget(status_label);
47

48
    /* 浮动窗口 */
49
    QDockWidget dock_widget("浮动窗口", &main_win); /* 创建浮动窗口 */
50
    dock_widget.setMinimumWidth(100); /* 设置最小宽度 */
51
    /* 将浮动窗口放在主窗口的左边 */
52
    main_win.addDockWidget(Qt::LeftDockWidgetArea, &dock_widget);
53

54
    /* 中心区域，别的控件占用了之后，剩下的区域都是CentralWidget */
55
    QWidget central_widget;
56
  QGridLayout central_layout;
57
  central_layout.setRowStretch(0, 1);
58
  central_layout.setColumnStretch(0, 1);
59
  central_layout.addWidget(new QLabel("用户名："), 1, 1);
60
  central_layout.addWidget(new QLineEdit(), 1, 2);
61
  central_layout.addWidget(new QLabel("密码："), 2, 1);
62
  central_layout.addWidget(new QLineEdit(), 2, 2);
63
  central_layout.setRowStretch(3, 1);
64
  central_layout.setColumnStretch(3, 1);
65
  central_widget.setLayout(&central_layout);
66
    main_win.setCentralWidget(&central_widget); /* 设置主窗口的中心区域 */
67

68
    main_win.show();
69

70
    /* 系统托盘图标 */
71
    QSystemTrayIcon tray_icon;
72
    tray_icon.setIcon(QIcon("image/滑稽.png")); /* 设置图标图片 */
73
    tray_icon.setContextMenu(file_menu);  /* 设置菜单 */
74
    tray_icon.show();
75

76
    app.exec();
77
    return 0;
78
}

展开收起

运行结果如下图：

菜单栏#

一个主窗口最多只有一个菜单栏。通过QMainWindow类的menuBar()函数可以获取主窗口菜单栏指针，如果当前窗口没有菜单栏，该函数会自动创建一个。

Qt 并没有专门的菜单项类，只是使用一个QAction类，抽象出公共的动作。当我们把QAction对象添加到菜单，就显示成一个菜单项，添加到工具栏，就显示成一个工具按钮。用户可以通过点击菜单项、点击工具栏按钮、点击快捷键来激活这个动作。

工具栏#

主窗口可以有多个工具栏，通常采用一个菜单对应一个工具栏的的方式，也可根据需要进行工具栏的划分。

调用QMainWindowd对象的成员函数addToolBar()会创建一个新的工具栏，并且返回该工具栏的指针。通过QToolBar类的addAction()函数可以添加插入属于工具栏的项，工具栏上添加项也是用QAction。

工具栏是一个可移动的窗口，它的可停靠区域由QToolBar的allowAreas决定，包括以下可用值：

Qt::LeftToolBarArea：停靠在左侧
Qt::RightToolBarArea：停靠在右侧
Qt::TopToolBarArea：停靠在顶部
Qt::BottomToolBarArea：停靠在底部
Qt::AllToolBarAreas：以上四个位置都可停靠

使用setAllowedAreas()函数指定停靠区域，使用setFloatable()函数可以设置工具栏是否可以浮动。

状态栏#

一个QMainWindow的程序最多只有一个状态栏。QMainWindow中可以有多个的部件都使用add…名字的函数，而只有一个的部件，就直接使用获取部件的函数，如menuBar。同理状态栏也提供了一个获取状态栏的函数statusBar()，没有就自动创建一个并返回状态栏的指针，状态栏可以使用addWidget()接口来添加内容。

浮动窗口#

即QDockWidget，也称为铆接部件，可以有多个。主窗口可以使用addDockWidget()成员函数添加浮动窗口。

中心区域#

除了以上几个部件占用的区域外，剩下的区域都是中心区域，中心区域只有一个，使用setCentralWidget()函数设置中心区域。

系统托盘图标#

系统托盘图标并不是QMainWindow里的内容，Qt 中使用QSystemTrayIcon类来创建系统托盘图标，可以使用QSystemTrayIcon的setIcon()成员函数设置图标，使用setContextMenu()设置鼠标右键菜单。

对话框#

抄了大佬的这篇博客。

对话框是GUI程序中不可或缺的组成部分。⼀些不适合在主窗⼝实现的功能组件可以设置在对话框中。对话框通常是⼀个顶层窗口，出现在程序最上层，⽤于实现短期任务或者简洁的用户交互。对话框主要可以分为模态对话框和⾮模态对话框。

Qt中的对话框类为QDialog，是QWidget的子类，QWidget的各种属性方法，在QDialog也同样适用。

模态对话框#

模态对话框的特点是：显示后无法与父窗口进行交互，是⼀种阻塞式的对话框。在 Qt 中使用QDialog::exec()函数调用。模态对话框适用于必须依赖用户选择的场合，⽐如消息显示，文件选择，打印设置等。

1
QDialog model_dialog;
2
model_dialog.setWindowTitle("模态对话框");
3
model_dialog.exec(); /* 阻塞显示对话框 */

非模态对话框#

非模态对话框的特点是：显示后独立存在，可以同时与父窗口进行交互，是⼀种非阻塞式对话框，使用QDialog::show()函数调用。⾮模态对话框⼀般在堆上创建，这是因为如果创建在栈上时，当函数运行结束后，弹出的⾮模态对话框会被释放。⾮模态对话框适用于特殊功能设置的场合，⽐如查找操作，属性设置等。

Qt 可以通过设置Qt:WA_DeleteOnClose属性，实现在对话框在关闭的时候被delete掉，避免内存泄漏。

1
QDialog *modaless_dialog = new QDialog();
2
modaless_dialog->setWindowTitle("非模态对话框");
3
/* 关闭窗口的时候触发delete操作，防止内存泄漏 */
4
modaless_dialog->setAttribute(Qt::WA_DeleteOnClose);
5
modaless_dialog->show(); /* 非阻塞显示对话框 */

Qt常用的对话框#

Qt 提供了多种可复复用的对话框类型，即Qt标准对话框。Qt标准对话框全部继承于QDialog类。常用标准对话框如下：

QMessageBox：消息对话框
QFileDialog：文件对话框
QColorDialog：颜色对话框
QFontDialog：字体对话框
QInputDialog：输入对话框

消息对话框#

消息对话框主要用于为用户提示重要消息，强制用户进行选择操作。QMessageBox提供了多种静态方法来快速显示不同类型的消息框：

information：显示一个信息消息框

1
QMessageBox::information(nullptr, "信息消息框", "假装这是一条信息消息");

warning：显示一个警告消息框

1
QMessageBox::warning(nullptr, "警告消息框", "假装这是一条警告消息");

critical：显示一个严重错误消息框

1
QMessageBox::critical(nullptr, "错误消息框", "假装这是一条错误消息");

question：显示一个问题消息框，允许用户做出选择

1
int ret = QMessageBox::question(nullptr, "问题消息框", "假装这是一个问题");
2
if (ret == QMessageBox::Yes) {
3
    qDebug() << "return yes";
4
}
5
else {
6
    qDebug() << "return no";
7
}

文件对话框#

文件对话框QFiledialog是一个模态对话框，主要用于让用户可以浏览文件系统、并选择文件或目录。

打开一个文件，返回文件的绝对路径

1
QString file_path = QFileDialog::getOpenFileName();

打开多个文件，返回文件的绝对路径列表

1
QStringList file_path_list = QFileDialog::getOpenFileNames();

1
QString dir_path = QFileDialog::getExistingDirectory();

保存文件，返回文件的绝对路径

1
QString file_path = QFileDialog::getSaveFileName();

颜色对话框#

颜色对话框QColorDialog是一个模态对话框，用于让用户选择颜色。

1
QColor color = QColorDialog::getColor();

字体对话框#

字体对话框QFontDialog也是一个模态对话框，用于让用户选择字体的样式、大小、粗细等属性。

1
bool flag = false;
2
QFont font = QFontDialog::getFont(&flag);

输入对话框#

输入对话框QInputDialog也是一个模态对话框，主要用于让用户输入文本、数字或选择列表中的一个选项。

浮点数输入对话框

1
double ret = QInputDialog::getDouble(nullptr, "输入对话框", "输入浮点数");

整数输入对话框

1
int ret = QInputDialog::getInt(nullptr, "输入对话框", "输入整数");

选项列表输入对话框

1
QString ret = QInputDialog::getItem(nullptr, "输入对话框", "选择选项",
2
                                    {"选项_1", "选项_2", "选项_3"});

画板#

抄了大佬的这篇博客。

QPainter是 Qt 中用于进行绘图操作的类。它提供了各种绘制函数，可以在不同的绘图设备上进行绘制，如窗口、图像、打印机等。

以下是QPainter类的一些常用属性和方法：

begin(QPaintDevice *device): 在给定的绘图设备上开始绘制操作。
end(): 结束绘制操作。
drawText(const QRectF &rectangle, const QString &text): 绘制指定矩形区域内的文本。
drawImage(const QRectF &target, const QImage &image, const QRectF &source): 在目标矩形区域内绘制源图像的一部分。
setPen(const QPen &pen): 设置绘制的画笔样式。
setBrush(const QBrush &brush): 设置绘制的画刷样式。
setFont(const QFont &font): 设置绘制的字体样式。
translate(const QPointF &offset): 将绘图坐标原点平移指定的偏移量。
scale(qreal sx, qreal sy): 沿着x轴和y轴方向对绘图进行缩放。
rotate(qreal angle): 以原点为中心，按照给定的角度旋转绘图。
save(): 保存当前的绘图状态，包括画笔、画刷、字体等设置。
restore(): 恢复上一次保存的绘图状态。

这些方法和属性只是QPainter类的一部分，还有其他许多功能可以用于绘制不同的图形和效果。可以根据需要在QPainter文档中进一步了解更多细节。

下面是一个简单的示例，演示了如何使用QPainter在窗口上进行绘制：

1
#include <QApplication>
2
#include <QWidget>
3
#include <QPainter>
4
#include <QPixmap>
5

6
class my_painter : public QWidget
7
{
8
private:
9
    /* data */
10
public:
11
    my_painter() {};
12
    ~my_painter() {};
13

14
    void paintEvent(QPaintEvent *e);
15
};
16

17
void my_painter::paintEvent(QPaintEvent *e)
18
{
19
    QPainter painter(this);
20

21
    /* 消锯齿 */
22
    painter.setRenderHint(QPainter::Antialiasing);
23
    /* 设置画笔，线条为红色，线宽为2，使用虚线 */
24
    painter.setPen(QPen(Qt::red , 2, Qt::DashLine));
25
    /* 设置画刷，当画矩形等封闭图形时，用黄色填充 */
26
    painter.setBrush(Qt::yellow);
27
    /* 设置字体，楷体，大小为40，700加粗，斜体 */
28
    painter.setFont(QFont("楷体", 40, 700, true));
29

30
    /* 画直线 */
31
    painter.drawLine(20, 40, 200, 40);
32
    /* 画圆 */
33
    painter.drawEllipse(QPoint(100, 120), 50, 50);
34
    /* 写字 */
35
    painter.drawText(QPoint(20, 240), "hello world");
36

37
    /* 向左移动400 */
38
    painter.translate(400, 0);
39
    /* 画图片 */
40
    painter.drawPixmap(QPoint(0, 20), QPixmap("./image/滑稽.png"));
41
    // /* 画矩形 */
42
    painter.drawRect(QRect(0, 120, 100, 50));
43
    // /* 画圆角矩形 */
44
    painter.drawRoundedRect(QRect(0, 200, 100, 50), 15, 15, Qt::AbsoluteSize);
45
}
46

47
int main(int argc, char *argv[])
48
{
49
  QApplication app(argc, argv);
50

51
  my_painter widget;
52
  widget.show();
53

54
  return app.exec();
55
}

展开收起

在上述示例中，我们创建了一个自定义的QWidget派生类my_painter，并重写了paintEvent()函数。在paintEvent()函数中，我们创建了一个QPainter对象，将其关联到窗口上，并使用一些绘制函数，在窗口的矩形区域内绘制图形。最后，我们创建了一个my_painter对象并显示窗口，绘制的图形将在窗口中心显示。运行的结果如下：

这只是一个简单的示例，你可以根据需要使用其他绘图函数和属性来绘制更复杂的图形和效果。

事件#

抄了大佬的这篇博客

事件定义#

事件(event)是由系统或者 Qt 本身在不同的时刻发出的。当用户按下鼠标，敲下键盘，或者是窗口需要重新绘制的时候，都会发出一个相应的事件。一些事件是在对用户操作做出响应的时候发出，如键盘事件等；另一些事件则是由系统自动发出，如计时器事件。

事件与信号槽#

一般来说，使用 Qt 编程时，我们并不会把主要精力放在事件上，因为在 Qt 中，需要我们关心的事件总会发出一个信号。比如，我们关心的是QPushButton的鼠标点击，但我们不需要关心这个鼠标点击事件，而是关心它的clicked()信号。

信号槽：signal由具体对象发出，然后会马上交给由connect函数连接的slot进行处理。
事件：Qt 使用一个事件队列对所有发出的事件进行维护，当新的事件产生时，会被追加到事件队列的尾部，前一个事件完成后，取出后面的事件进行处理。但是，必要的时候，Qt 的事件也是可以不进入事件队列，而是直接处理的。并且，事件还可以使用“事件过滤器”进行过滤。

总的来说，如果我们使用组件，我们关心的是信号槽；如果我们自定义组件，我们关心的是事件。因为我们可以通过事件来改变组件的默认操作。比如，如果我们要自定义一个QPushButton，那么我们就需要重写它的鼠标点击事件和键盘处理事件，并且在恰当的时候发出clicked()信号。

事件循环#

我们在 main 函数里面创建了一个QApplication对象，然后调用了它的exec()函数。其实，这个函数就是开始 Qt 的事件循环。在执行exec()函数之后，程序将进入事件循环来监听应用程序的事件。

事件处理函数#

当事件发生时，Qt 将创建一个事件对象。Qt 的所有事件都继承于QEvent类。在事件对象创建完毕后，Qt 将这个事件对象传递给 QObject 的event()函数。event()函数并不直接处理事件，而是按照事件对象的类型分派给特定的事件处理函数(event handler) 。

例如在所有组件的父类 QWidget 中，定义了很多事件处理函数，如keyPressEvent()、keyReleaseEvent()、mouseDoubleClickEvent()、mouseMoveEvent ()、mousePressEvent()、mouseReleaseEvent()等。这些函数都是protected virtual的，也就是说，我们应该在子类中重写这些函数。下面是一个重写事件处理函数的例子：

1
#include <QApplication>
2
#include <QWidget>
3
#include <QMouseEvent>
4
#include <QKeyEvent>
5
#include <QDebug>
6

7
class event_widget : public QWidget
8
{
9
protected:
10
    /* 事件处理主函数，主要用来截取事件 */
11
    bool event(QEvent *ev);
12

13
    /* 鼠标按下事件处理 */
14
    void mousePressEvent(QMouseEvent *ev);
15
    /* 鼠标释放事件处理 */
16
    void mouseReleaseEvent(QMouseEvent *ev);
17
    /* 鼠标移动事件处理 */
18
    void mouseMoveEvent(QMouseEvent *ev);
19
    /* 鼠标双击事件处理 */
20
    void mouseDoubleClickEvent(QMouseEvent *ev);
21

22
    /* 键盘按下事件处理 */
23
    void keyPressEvent(QKeyEvent *ev);
24
    /* 键盘释放事件处理 */
25
    void keyReleaseEvent(QKeyEvent *ev);
26

27
    /* 窗口隐藏事件处理 */
28
    void hideEvent(QHideEvent *ev);
29
    /* 窗口显示事件处理 */
30
    void showEvent(QShowEvent *ev);
31
    /* 重绘事件处理 */
32
    void paintEvent(QPaintEvent *ev);
33
    /* 窗口关闭事件处理 */
34
    void closeEvent(QCloseEvent *ev);
35
};
36

37
/* 事件处理主函数，主要用于事件的分发 */
38
bool event_widget::event(QEvent *ev)
39
{
40
    /* 默认的事件处理函数 */
41
    return QWidget::event(ev);
42
}
43

44
/* 鼠标按下事件处理 */
45
void event_widget::mousePressEvent(QMouseEvent *ev)
46
{
47
    qDebug() << "mouse press event";
48
    QWidget::mousePressEvent(ev);
49
}
50

51
/* 鼠标释放事件处理 */
52
void event_widget::mouseReleaseEvent(QMouseEvent *ev)
53
{
54
    qDebug() << "mouse release event";
55
    QWidget::mouseReleaseEvent(ev);
56
}
57

58
/* 鼠标移动事件处理 */
59
void event_widget::mouseMoveEvent(QMouseEvent *ev)
60
{
61
    static int i = 0;
62
    /* 只有鼠标按下时移动，才能触发事件 */
63
    qDebug() << "mouse move " << i++;
64
    /* 如果要在鼠标不按下时，也触发事件，需要在构造函数中运行下面的代码 */
65
    // this->setMouseTracking(true);
66
    QWidget::mouseMoveEvent(ev);
67
}
68

69
/* 鼠标双击事件处理 */
70
void event_widget::mouseDoubleClickEvent(QMouseEvent *ev)
71
{
72
    qDebug() << "mouse double click event";
73
    QWidget::mouseDoubleClickEvent(ev);
74
}
75

76
/* 键盘按下事件处理 */
77
void event_widget::keyPressEvent(QKeyEvent *ev)
78
{
79
    qDebug() << "key press event " << ev->key();
80
    QWidget::keyPressEvent(ev);
81
}
82

83
/* 键盘释放事件处理 */
84
void event_widget::keyReleaseEvent(QKeyEvent *ev)
85
{
86
    qDebug() << "key release event " << ev->key();
87
    QWidget::keyPressEvent(ev);
88
}
89

90
/* 窗口隐藏事件处理 */
91
void event_widget::hideEvent(QHideEvent *ev)
92
{
93
    qDebug() << "hide event";
94
    QWidget::hideEvent(ev);
95
}
96

97
/* 窗口显示事件处理 */
98
void event_widget::showEvent(QShowEvent *ev)
99
{
100
    qDebug() << "show event";
101
    QWidget::showEvent(ev);
102
}
103

104
/* 重绘事件处理 */
105
void event_widget::paintEvent(QPaintEvent *ev)
106
{
107
    qDebug() << "paint event";
108
    QWidget::paintEvent(ev);
109
}
110

111
/* 窗口关闭事件处理 */
112
void event_widget::closeEvent(QCloseEvent *ev)
113
{
114
    qDebug() << "close event";
115
    QWidget::closeEvent(ev);
116
}
117

118
int main(int argc, char *argv[])
119
{
120
    QApplication app(argc, argv);
121

122
    event_widget widget;
123
    widget.show();
124

125
    return app.exec();
126
}

展开收起

上面的例子中，我们定义了一个QWidget的子类event_widget，重写了一些事件处理函数。

事件接受与忽略#

前面的例子中我们在重写事件处理函数时，都会调用父类对应的事件处理函数。这在某种程度上说，是把事件向上传递给父类去响应，也就是说，我们在子类中“忽略”了这个事件。

我们可以把 Qt 的事件传递看成链状：如果子类没有处理这个事件，就会继续向其他类传递。其实，Qt 的事件对象都有一个accept()函数和ignore()函数。正如它们的名字，前者用来告诉 Qt，事件处理函数“接收”了这个事件，不要再传递；后者则告诉 Qt，事件处理函数“忽略”了这个事件，需要继续传递，寻找另外的接受者。在事件处理函数中，可以使用isAccepted()来查询这个事件是不是已经被接收了。

事实上，我们很少使用accept()和ignore()函数，而是像上面的示例一样，如果希望忽略事件，只要调用父类的响应函数即可。

Qt 中的事件大部分是protected的，因此，重写的函数必定存在着其父类中的响应函数，这个方法是可行的。为什么要这么做呢？因为我们无法确认父类中的这个处理函数没有操作，如果我们在子类中直接忽略事件，Qt 不会再去寻找其他的接受者，那么父类的操作也就不能进行，这可能会有潜在的危险。

在一个情形下，我们必须使用accept()和ignore()函数，那就是在窗口关闭的时候。如果在窗口关闭时需要有个询问对话框，那么就需要这么去写：

1
/* 窗口关闭事件处理 */
2
void event_widget::closeEvent(QCloseEvent * event)
3
{
4
    QMessageBox::StandardButton ret;
5
    ret = QMessageBox::question(this, "Quit",
6
        "Are you sure to quit this application",
7
        QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
8
    if(ret == QMessageBox::Yes) {
9
        event->accept();
10
    } else {
11
        event->ignore();
12
    }
13
}

这样，我们经过询问之后才能正常退出程序。

event()函数#

事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是将这些事件对象按照它们不同的类型，分发给不同的事件处理器(event handler)。

event()函数主要用于事件的分发，所以，如果希望在事件分发之前做一些操作，那么，就需要注意这个event()函数了。为了达到这种目的，我们可以重写event()函数。

例如，如果希望在窗口中的 tab 键按下时将焦点移动到下一组件，而不是让具有焦点的组件处理，那么就可以继承 QWidget ，并重写它的event()函数，以达到这个目的：

1
bool MyWidget::event(QEvent *event)
2
{
3
    if (event->type() == QEvent::KeyPress)
4
    {
5
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
6
        if (keyEvent->key() == Qt::Key_Tab)
7
        {
8
            // 处理 Tab 键时事件
9
            return true;
10
        }
11
    }
12
    return QWidget::event(event);
13
}

event()函数接受一个 QEvent 对象，也就是需要这个函数进行转发的对象。为了进行转发，必定需要有一系列的类型判断，这就可以调用 QEvent 的type()函数，其返回值是QEvent::Type类型的枚举。

我们处理过自己需要的事件后，可以直接return 回去，对于其他我们不关心的事件，需要调用父类的event()函数继续转发，否则这个组件就只能处理我们定义的事件了。

event()函数返回值是bool类型，如果传入的事件已被识别并且处理，返回true，否则返回false。如果返回值是true，QApplication 会认为这个事件已经处理完毕，会继续处理事件队列中的下一事件；如果返回值是false，QApplication 会尝试寻找这个事件的下一个处理函数。

event()函数的返回值和事件的accept()和ignore()函数不同。accept()和ignore()函数用于不同的事件处理器之间的沟通，例如判断这一事件是否处理；event()函数的返回值主要是通知 QApplication 的notify()函数是否处理下一事件。

为了更加明晰这一点，我们来看看 QWidget 的event()函数是如何定义的：

1
bool QWidget::event(QEvent *event)
2
{
3
    switch (e->type())
4
    {
5
        case QEvent::KeyPress:
6
            keyPressEvent((QKeyEvent *)event);
7
            if (!((QKeyEvent *)event)->isAccepted())
8
                return false;
9
            break;
10
        case QEvent::KeyRelease:
11
            keyReleaseEvent((QKeyEvent *)event);
12
            if (!((QKeyEvent *)event)->isAccepted())
13
                return false;
14
            break;
15
        // more...
16
    }
17
    return true;
18
}

展开收起

QWidget 的event()函数使用一个巨大的 switch 来判断 QEvent 的 type，并且分发给不同的事件处理函数。在事件处理函数之后，使用这个事件的isAccepted()方法，获知这个事件是不是被接受，如果没有被接受则event()函数立即返回false，否则返回true。

另外一个必须重写event()函数的情形是有自定义事件的时候。如果程序中有自定义事件，则必须重写event()函数以便将自定义事件进行分发，否则自定义事件永远也不会被调用。

事件过滤器#

Qt 创建了 QEvent 事件对象之后，会调用 QObject 的event()函数做事件的分发。有时候，可能需要在调用event()函数之前做一些另外的操作，比如，对话框上某些组件可能并不需要响应回车按下的事件，此时，就需要重新定义组件的event()函数。如果组件很多，就需要重写很多次event()函数，这显然没有效率。为此，可以使用一个事件过滤器，来判断是否需要调用event()函数。

QOjbect 有一个eventFilter()函数，用于建立事件过滤器。这个函数的签名如下：

1
virtual bool QObject::eventFilter(QObject * watched, QEvent * event)

如果 watched 对象安装了事件过滤器，这个函数会被调用并进行事件过滤，然后才轮到组件进行事件处理。在重写这个函数时，如果需要过滤掉某个事件，例如停止对这个事件的响应，需要返回true。

1
/* 重载消息过滤器 */
2
bool event_filter_t::eventFilter(QObject *o, QEvent *e)
3
{
4
    if (e->type() == QEvent::MouseButtonPress ||
5
        e->type() == QEvent::MouseButtonRelease ||
6
        e->type() == QEvent::MouseButtonDblClick)
7
    {
8
    QPushButton *button = static_cast<QPushButton *>(o);
9
        qDebug() << button->text() << "button mouse event";
10
        return true;
11
    }
12
    return QObject::eventFilter(o, e);
13
}

上面的例子中为 event_filter_t 建立了一个事件过滤器。为了过滤某个组件上的事件，首先需要判断这个对象是哪个组件，然后判断这个事件的类型。

例如，我不想让 textEdit 组件处理键盘事件，于是就首先找到这个组件，如果这个事件是键盘事件，则直接返回true，也就是过滤掉了这个事件。对于其他组件，我们并不保证是不是还有过滤器，于是最保险的办法是调用父类的函数。

在创建了过滤器之后，下面要做的是安装这个过滤器。安装过滤器需要调用installEventFilter()函数。这个函数的签名如下：

1
void QObject::installEventFilter(QObject* filterObj)

这个函数是 QObject 的一个函数，因此可以安装到任何 QObject 的子类，并不仅仅是 UI 组件。这个函数接收一个 QObject 对象，调用了这个函数安装事件过滤器的组件会调用 filterObj 定义的eventFilter()函数。

例如，textField.installEventFilter(obj)，则如果有事件发送到 textField 组件是，会先调用obj->eventFilter()函数，然后才会调用textField.event()。

当然，你也可以把事件过滤器安装到 QApplication 上面，这样就可以过滤所有的事件，已获得更大的控制权。不过，这样做的后果就是会降低事件分发的效率。

如果一个组件安装了多个过滤器，则最后一个安装的会最先调用，类似于堆栈的行为。

注意：如果你在事件过滤器中delete了某个接收组件，务必将返回值设为true。否则，Qt 还是会将事件分发给这个接收组件，从而导致程序崩溃。

事件过滤器和被安装的组件必须在同一线程，否则，过滤器不起作用。另外，如果在 install 之后，这两个组件到了不同的线程，那么，只有等到二者重新回到同一线程的时候过滤器才会有效。

事件的调用最终都会调用 QCoreApplication 的notify()函数，因此，最大的控制权实际上是重写 QCoreApplication 的notify()函数。由此可以看出，Qt 的事件处理实际上是分层五个层次：

重定义事件处理函数
重定义 event()函数
为单个组件安装事件过滤器
为 QApplication 安装事件过滤器
重定义 QCoreApplication 的notify()函数

这几个层次的控制权是逐层增大的。

自定义事件#

Qt 允许创建自己的事件类型，这在多线程的程序中尤其有用，当然，也可以用在单线程的程序中，作为一种对象间通讯的机制。那么，为什么需要使用事件，而不是使用信号槽呢？主要原因是，事件的分发既可以是同步的，又可以是异步的，而函数的调用或者说是槽的回调总是同步的。事件的另外一个好处是，它可以使用过滤器。

Qt 中的自定义事件很简单，同其他类似的库的使用很相似，都是要继承一个类进行扩展。在 Qt 中，你需要继承的类是QEvent。

继承 QEvent 类，你需要提供一个QEvent::Type类型的参数，作为自定义事件的类型值。这里的 QEvent::Type 类型是 QEvent 里面定义的一个 enum，因此，你是可以传递一个 int 的。重要的是，你的事件类型不能和已经存在的 type 值重复，否则会有不可预料的错误发生！因为系统会将你的事件当做系统事件进行派发和调用。

在 Qt 中，系统将保留0 - 999的值，也就是说，你的事件 type 要大于999. 具体来说，你的自定义事件的 type 要在 QEvent::User 和 QEvent::MaxUser 的范围之间。其中，QEvent::User 值是1000，QEvent::MaxUser 的值是65535。从这里知道，你最多可以定义64536个事件，相信这个数字已经足够大了！

但是，即便如此，也只能保证用户自定义事件不能覆盖系统事件，并不能保证自定义事件之间不会被覆盖。为了解决这个问题，Qt 提供了一个函数：registerEventType()，用于自定义事件的注册。该函数签名如下：

1
static int QEvent::registerEventType(int hint = -1);

函数是 static 的，因此可以使用 QEvent 类直接调用。函数接受一个 int 值，其默认值为-1，返回值是创建的这个 Type 类型的值。如果 hint 是合法的，不会发生任何覆盖，则会返回这个值；如果hint不合法，系统会自动分配一个合法值并返回。因此，使用这个函数即可完成 type 值的指定。这个函数是线程安全的，因此不必另外添加同步。

你可以在 QEvent 子类中添加自己的事件所需要的数据，然后进行事件的发送。Qt 中提供了两种发送方式：

static bool QCoreApplication::sendEvent(QObjecy receiver, QEvent event)：事件被 QCoreApplication 的 notify()函数直接发送给 receiver 对象，返回值是事件处理函数的返回值。使用这个函数必须要在栈上创建事件对象，例如：

1
QMouseEvent event(QEvent::MouseButtonPress, pos, 0, 0, 0);
2
QApplication::sendEvent(mainWindow, &event);

static bool QCoreApplication::postEvent(QObject receiver, QEvent event)：事件被 QCoreApplication 追加到事件列表的最后，并等待处理，该函数将事件追加后会立即返回，并且注意，该函数是线程安全的。另外一点是，使用这个函数必须要在堆上创建对象，例如：

1
QApplication::postEvent(object, new MyEvent(QEvent::registerEventType(2048)));

这个对象不需要手动 delete，Qt 会自动 delete 掉！因此，如果在 post 事件之后调用 delete，程序可能会崩溃。另外，postEvent()函数还有一个重载的版本，增加一个优先级参数，具体请参见API。通过调用 sendPostedEvent()函数可以让已提交的事件立即得到处理。

如果要处理自定义事件，可以重写 QObject 的customEvent()函数，该函数接收一个 QEvent 对象作为参数，也可以像前面介绍的重写event()函数的方法去重写这个函数，这两种办法都是可行的。下面是一个使用自定义信号的例子：

1
#include <QApplication>
2
#include <QWidget>
3
#include <QPushButton>
4
#include <QEvent>
5
#include <QDebug>
6

7
/* 初始化自定义的事件类型值 */
8
static const int CUSTOM_EVENT_TYPE = QEvent::registerEventType();
9

10
/* 自定义事件类 */
11
class custom_event_t : public QEvent
12
{
13
public:
14
  custom_event_t() : QEvent((QEvent::Type)CUSTOM_EVENT_TYPE) {};
15
};
16

17
class main_widgt_t : public QWidget
18
{
19
public:
20
    main_widgt_t() : QWidget() {};
21

22
    bool event(QEvent *e);
23
    void customEvent(QEvent *e);
24
};
25

26
/* 重载事件处理函数 */
27
bool main_widgt_t::event(QEvent *e)
28
{
29
    if(e->type() == CUSTOM_EVENT_TYPE)
30
    {
31
        qDebug() << "event() get custom event\n";
32
    }
33
    return QObject::event(e);
34
}
35

36
/* 重载自定义事件处理函数 */
37
void main_widgt_t::customEvent(QEvent *e)
38
{
39
    if(e->type() == CUSTOM_EVENT_TYPE)
40
    {
41
        qDebug() << "customEvent() get custom event\n";
42
    }
43
}
44

45
int main(int argc, char *argv[])
46
{
47
  QApplication app(argc, argv);
48
  main_widgt_t main_w;
49

50
    qDebug() << "CUSTOM_EVENT_TYPE: " << CUSTOM_EVENT_TYPE;
51

52
  QPushButton button("send custom event");
53
  button.setParent(&main_w);
54

55
    /* 使用lambda表达式连接button的点击事件 */
56
  QObject::connect(&button, &QPushButton::clicked, [&main_w]()
57
  {
58
        custom_event_t custom_event;
59
        /* 给main_w发送自定义事件 */
60
        QApplication::sendEvent(&main_w, &custom_event);
61
  });
62

63
  main_w.show();
64
  return app.exec();
65
}

展开收起

信号和槽#

抄了大佬的这篇博客。

简介#

信号槽是QT中用于对象间通信的一种机制，也是QT的核心机制。在GUI编程中，我们经常需要在改变一个组件的同时，通知另一个组件做出响应。

早期，对象间的通信采用回调来实现。回调实际上是利用函数指针来实现，当我们希望某件事发生时处理函数能够获得通知，就需要将回调函数的指针传递给处理函数，这样处理函数就会在合适的时候调用回调函数。回调有两个明显的缺点：

它们不是类型安全的，我们无法保证处理函数传递给回调函数的参数都是正确的。
回调函数和处理函数紧密耦合，源于处理函数必须知道哪一个函数被回调。

在QT中，我们有回调技术之外的选择，也即是信号槽机制。所谓的信号与槽，其实都是函数。当特定事件被触发时将发送一个信号，而与该信号建立的连接槽，则可以接收到该信号并做出反应。

QT组件预定义了很多信号和槽，而在GUI编程中，我们习惯于继承那些组件，继承后添加我们自己的槽，以便以我们的方式来处理信号。槽和普通的C++成员函数几乎是一样的，它可以是虚函数，可以被重载，可以是共有、私有或是保护的，也同样可以被其他成员函数调用。它的函数参数也可以是任意类型的。唯一不同的是：槽还可以和信号连接在一起。

与回调不同，信号槽机制是类型安全的。这体现在信号的函数签名与槽的函数签名必须匹配上，才能够发生信号的传递。实际上，槽的参数个数可以比信号的参数个数少，因为槽能够忽略信号形参中多出来的参数。信号和槽是松耦合的：发出信号的类不关心哪些类将接收它的信号。QT的槽能够接收到信号的参数并调用，信号和槽都可以有任意个数的参数，它们都是类型安全的。

样例分析#

首先我们要知道的是，所有继承自QObject或者它的子类（如QWidget）都可以包含信号槽。我们写的类也要继承自QObject（或其子类）。所有包含了信号和槽的类都必须在声明的上部含有Q_OBJECT宏。

下面是一个样例，一个定义了信号的类和一个定义了槽函数的类：

1
#ifndef __MY_SIGHNAL_H__
2
#define __MY_SIGHNAL_H__
3

4
#include <QObject>
5

6
/* 一个定义了信号的类 */
7
class my_signal : public QObject
8
{
9
    Q_OBJECT
10

11
private:
12
    int _id = 0;
13

14
public:
15
    my_signal(int id_) : QObject(), _id(id_) {};
16

17
    int get_id()
18
    {
19
        return _id;
20
    }
21

22
signals:
23
    /* 信号 */
24
    void signal_fun(const char *str, int num = 0);
25
};
26

27
#endif /* __MY_SIGHNAL_H__ */

展开收起

1
#ifndef __MY_SLOT_H__
2
#define __MY_SLOT_H__
3

4
#include <QObject>
5
#include <QDebug>
6

7
#include "my_signal.h"
8

9
/* 一个定义了槽函数的类 */
10
class my_slot : public QObject
11
{
12
    Q_OBJECT
13

14
private:
15
    int _id = 0;
16

17
public:
18
    my_slot(int id_) : QObject(), _id(id_) {};
19

20
    int get_id()
21
    {
22
        return _id;
23
    }
24

25
public slots:
26
    /* 槽函数 */
27
    virtual void slot_fun(const char *str)
28
    {
29
    my_signal *sign = static_cast<my_signal *>(sender());
30
        qDebug() << "my_slot: " << get_id()
31
                 << " get my_sign: " << sign->get_id()
32
                 << " str: " << str;
33
    }
34
};
35

36
#endif /* __MY_SLOT_H__ */

展开收起

在这个信号类中，我们使用Qt的signals保留字定义了一个信号函数signal_fun()，signal_fun()的代码会由 Qt 的 moc 工具自动生成，开发人员一定不能在自己的C++代码中实现它。反之，槽应该由开发人员来实现，在槽函数里可以使用sender()来获取信号的发送方。需要注意的是，必须在 pro 工程文件里，使用HEADERS添加定义了信号或槽函数类的头文件，如果只是使用INCLUDEPATH添加头文件的路径，Qt 不会调用 moc 生成代码。

可以使用QObject::connect()函数连接信号和槽，该函数指定了信号发送方、信号函数、信号接收方、槽函数等信息，函数的格式如下：

1
QObject::connect(
2
    QObject* sender,      /* 信号发送方 */
3
    SIGNAL(signal_fun()), /* 信号函数 */
4
    QObject* receiver,    /* 信号接收方 */
5
    SLOT(slot_fun()));    /* 槽函数 */

最后，我们可以使用 Qt 的emit关键字发送信号，下面是一个使用connect()和emit的简单样例：

1
#include <QCoreApplication>
2

3
#include "my_signal.h" /* 定义了信号的类 */
4
#include "my_slot.h"   /* 定义了槽函数的类 */
5

6
int main(int argc, char *argv[])
7
{
8
  QCoreApplication app(argc, argv);
9

10

11
    my_signal sign(1); /* 信号发送方 */
12
    my_slot slot(1);   /* 信号接收方 */
13

14
    /* 连接信号和槽 */
15
    QObject::connect(&sign, SIGNAL(signal_fun(const char *, int)),
16
                     &slot, SLOT(slot_fun(const char *)));
17

18
    /* 发送信号 */
19
    emit sign.signal_fun("hello word 1", 1);
20

21
  return app.exec();
22
}

展开收起

上面的例子中，信号函数有两个参数，而槽函数只有一个参数，信息函数的第二个参数会被槽函数忽略。这个例子展示了对象之间通信的一种方式。对象间可以一起工作，而不需要知道彼此的任何信息。为了达到通信的目的，只需要将它们连接起来，而这只需要通过调用QObject::connect()函数指定一些简单信息就好。

连接#

要把信号成功连接到槽，它们的参数必须具有相同的顺序和相同的类型，或者允许信号的参数比槽多，槽会自动忽略掉多出来的参数而进行调用。

一个信号可以连接多个槽#

使用QObject::connect可以把一个信号连接到多个槽，而当信号发射时，将按声明联系时的顺序依次调用槽。

1
    my_signal sign;
2
    my_slot slot_1, slot_2;
3

4
    /* 信号连接到两个槽 */
5
    QObject::connect(&sign, SIGNAL(signal_fun(const char *, int)),
6
                     &slot_1, SLOT(slot_fun(const char *)));
7
    QObject::connect(&sign, SIGNAL(signal_fun(const char *, int)),
8
                     &slot_2, SLOT(slot_fun(const char *)));
9

10
    /* 发送信号 */
11
    emit sign.signal_fun("hello word", 1);
12
    /* 依次调用 slot_1.slot_fun()、slot_2.slot_fun() */

多个信号可以连接同一个槽#

同样的，可以让多个信号连接到同一个槽上，而且其中的任意一个信号的发送，都会调用了那个槽。

1
    my_signal sign_1, sign_2;
2
    my_slot slot;
3

4
    /* 两个信号连接到同一个槽上 */
5
    QObject::connect(&sign_1, SIGNAL(signal_fun(const char *, int)),
6
                     &slot, SLOT(slot_fun(const char *)));
7
    QObject::connect(&sign_2, SIGNAL(signal_fun(const char *, int)),
8
                     &slot, SLOT(slot_fun(const char *)));
9

10
    /* 发送信号，两个信号都会触发槽函数slot.slot_fun()的调用 */
11
    emit sign_1.signal_fun("hello word 1", 1);
12
    emit sign_2.signal_fun("hello word 2", 1);

一个信号可以和另外一个信号相连接#

当发送第一个信号的时候，也会把第二个信号发送出去。

1
    my_signal sign_1, sign_2;
2
    my_slot slot;
3

4
    /* 两个信息号相连 */
5
    QObject::connect(&sign_1, SIGNAL(signal_fun(const char *, int)),
6
                     &sign_2, SIGNAL(signal_fun(const char *, int)));
7
    /* 两个信号连接到同一个槽上 */
8
    QObject::connect(&sign_1, SIGNAL(signal_fun(const char *, int)),
9
                     &slot, SLOT(slot_fun(const char *)));
10
    QObject::connect(&sign_2, SIGNAL(signal_fun(const char *, int)),
11
                     &slot, SLOT(slot_fun(const char *)));
12

13
    /* 发送信号1，信号2也会发送出去 */
14
    emit sign_1.signal_fun("hello word 1", 1);
15
    /* 发送信号2，信号1不会被发送出去 */
16
    emit sign_2.signal_fun("hello word 2", 1);

展开收起

连接可以被移除#

1
/* 移除sign.signal_fun()与slot.slot_fun()之间的连接 */
2
QObject::disconnect(&sign, SIGNAL(signal_fun(const char *, int)),
3
                    &slot, SLOT(slot_fun(const char *)));

实际上当对象被delete时，其关联的所有连接都会失效，QT会自动移除和这个对象的所有连接。

文件操作#

文件读写#

数据流#

缓存#

内存映射#

哈夫曼树

Tue, 04 Jan 2022 00:00:00 GMT

先说两句#

这篇博客大部分也是抄的，原文地址。

定义#

哈夫曼树，又称最优树，是一类带权路径长度最短的树。首先有几个概念需要清楚：

路径和路径长度#

从树中一个结点到另一个结点之间的分支构成两个结点的路径，路径上的分支数目叫做路径长度。树的路径长度是从树根到每一个结点的路径长度之和。

带权路径长度#

结点的带权路径长度为从该结点到树根之间的路径长度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和，通常记作WPL。

若有n个权值为w1,w2,…,wn的结点构成一棵有n个叶子结点的二叉树，则树的带权路径最小的二叉树叫做哈夫曼树或最优二叉树。

在上图中，3棵二叉树都有4个叶子结点a、b、c、d，分别带权7、5、2、4，则它们的带权路径长度为：

（a）WPL = 7×2 + 5×2 + 2×2 + 4×2 = 36 （b）WPL = 4×2 + 7×3 + 5×3 + 2×1 = 46 （c）WPL = 7×1 + 5×2 + 2×3 + 4×3 = 35

其中(c)的WPL最小，可以验证，(c)恰为哈夫曼树。

哈夫曼树的创建#

假设有n个结点，n个结点的权值分别为w1,w2,…,wn，这n个结点可以看作n个只有一个树根结点的二叉树，构成的二叉树的集合为F={T1,T2,…,Tn}。基于F，可以构造一棵含有n个叶子结点的哈夫曼树，步骤如下：

从F中选取两棵根结点权值最小的树作为左右子树构造一棵新的二叉树，其新的二叉树的权值为其左右子树根结点权值之和；
从F中删除上一步选取的两棵二叉树，将新构造的树放到F中；
重复第1步和第2步，直到F只含一棵树为止。

下面是一个构建哈夫曼树的例子：

从上面的步骤可以看出，每次都需要选取F中权值最小的两个结点，原文中，大佬用了最小堆优化查找，为了让算法简单易懂（顺便偷个懒），我就直接用数组遍历查找。

创建哈夫曼树的C语言实现：

1
#include <stdio.h>
2
#include <string.h>
3
#include <stdlib.h>
4

5
#define MAX_DATA_LEN 20
6

7
typedef struct tree_node
8
{
9
  char data;
10
  int weight;
11
  struct tree_node *left_child;
12
  struct tree_node *right_child;
13
} tree_node;
14

15
/**
16
 * @brief : 遍历结点列表，返回权重最小结点的位置
17
 * @param nodes : [in]结点列表
18
 * @param book : [in]标记数组，标记对应结点是否已经使用过
19
 * @param node_num : [in]结点的个数
20
 * @return : 权重最小结点的位置
21
 */
22
int find_min_weight_index(tree_node *nodes[], int book[], int node_num)
23
{
24
  int i, index, min_weight;
25

26
  min_weight = 0x3FFFFFFF;
27
  index = -1;
28
  for(i = 0; i < node_num; i++)
29
  {
30
    if(book[i] == 0 && nodes[i]->weight < min_weight)
31
    {
32
      index = i;
33
      min_weight = nodes[i]->weight;
34
    }
35
  }
36
  return index;
37
}
38

39
/**
40
 * @brief : 构建哈夫曼树
41
 * @param data_list : [in]数据数组
42
 * @param weight_list : [in]权重数组
43
 * @param data_len : [in]数据个数
44
 * @return : 构建好的哈夫曼树的头结点地址
45
 */
46
tree_node *build_huffman_tree(char data_list[], int weight_list[], int data_len)
47
{
48
  tree_node *nodes[MAX_DATA_LEN * 2];
49
  int book[MAX_DATA_LEN * 2];
50
  int i, node_num, index_1, index_2;
51

52
  node_num = 0;
53
  for(i = 0; i < data_len; i++)
54
  {
55
    nodes[i] = (tree_node *)malloc(sizeof(tree_node));
56
    nodes[i]->data = data_list[i];
57
    nodes[i]->weight = weight_list[i];
58
    node_num++;
59
  }
60
  memset(book, 0, sizeof(book));
61

62
  for(i = 1; i < data_len; i++)
63
  {
64
    index_1 = find_min_weight_index(nodes, book, node_num);
65
    book[index_1] = 1;
66
    index_2 = find_min_weight_index(nodes, book, node_num);
67
    book[index_2] = 1;
68

69
    nodes[node_num] = (tree_node *)malloc(sizeof(tree_node));
70
    nodes[node_num]->data = -1;
71
    nodes[node_num]->weight = nodes[index_1]->weight + nodes[index_2]->weight;
72
    nodes[node_num]->left_child = nodes[index_1];
73
    nodes[node_num]->right_child = nodes[index_2];
74
    node_num++;
75
  }
76
  return nodes[node_num - 1];
77
}
78

79
int main(int argc, char *argv[])
80
{
81
  int i, data_len = 7;
82
  char data_list[MAX_DATA_LEN] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
83
  int weight_list[MAX_DATA_LEN] = {8, 7, 4, 5, 20, 15, 1};
84

85
  tree_node *root = build_huffman_tree(data_list, weight_list, data_len);
86

87
  return 0;
88
}

展开收起

哈夫曼编码#

我们约定左分支表示字符`0’，右分支表示字符’1’，在哈夫曼树中从根结点开始，到叶子结点的路径上分支字符组成的字符串为该叶子结点的哈夫曼编码。上面代码所创建的哈夫曼树如下所示：

可以看出3被编码为00，1为010，2为011,4为10,5为11。在这些编码中，任何一个字符的编码均不是另一个字符编码的前缀。

输出所有哈夫曼编码的代码：

1
/**
2
 * @brief : 输出所有哈夫曼编码
3
 * @param root : [in]树根结点地址
4
 * @param path : [in]用来记录路径
5
 * @param depth : [in]当前结点的深度
6
 * @return : None
7
 */
8
void print_huffman_code(tree_node *root, char path[], int depth)
9
{
10
  int i;
11

12
  if(root != NULL)
13
  {
14
    if(root->data > 0)
15
    {
16
      printf("%c: ", root->data);
17
      for(i = 0; i < depth; i++)
18
      {
19
        printf("%d", path[i]);
20
      }
21
      printf("\n");
22
    }
23
    else
24
    {
25
      path[depth] = 0;
26
      print_huffman_code(root->left_child, path, depth + 1);
27
      path[depth] = 1;
28
      print_huffman_code(root->right_child, path, depth + 1);
29
    }
30
  }
31
}

展开收起

线索二叉树

Wed, 29 Dec 2021 00:00:00 GMT

先说两句#

前几天考研题里，考到了线索二叉树和哈夫曼树，之前打acm的时侯没遇到过关于这两个的题目，所以就一直懒得学，考研要考，只好花点时间学一下了。本文大部分内容参考自大佬的这篇博客，好吧，几乎就是照抄。

线索二叉树产生背景#

现有一棵结点数目为n的二叉树，采用二叉链表的形式存储。对于每个结点均有指向左右孩子的两个指针域，而结点为n的二叉树一共有n-1条有效分支路径。那么，则二叉链表中存在2n-(n-1)=n+1个空指针域。那么，这些空指针造成了空间浪费。

例如：图1所示一棵二叉树一共有10个结点，空指针^有11个。

图1

此外，当对二叉树进行中序遍历时可以得到二叉树的中序序列。例如：图1所示二叉树的中序遍历结果为HDIBJEAFCG，可以得知A的前驱结点为E，后继结点为F。但是，这种关系的获得是建立在完成遍历后得到的，那么可不可以在建立二叉树时就记录下前驱后继的关系呢，那么在后续寻找前驱结点和后继结点时将大大提升效率。

线索化#

现将某结点的空指针域指向该结点的前驱后继，定义规则如下：

若结点的左子树为空，则该结点的左孩子指针指向其前驱结点。若结点的右子树为空，则该结点的右孩子指针指向其后继结点。

这种指向前驱和后继的指针称为线索。将一棵普通二叉树以某种次序遍历，并添加线索的过程称为线索化。

按照规则将图1所示二叉树线索化后如图2所示：

图2

图中黑色点画线为指向后继的线索，紫色虚线为指向前驱的线索。可以看出通过线索化，既解决了空间浪费问题，又解决了前驱后继的记录问题。

线索化带来新问题#

经过第3节的讲解后，可以将一棵二叉树线索化为一棵线索二叉树，那么新的问题产生了。我们如何区分一个结点的lchild指针是指向左孩子还是前驱结点呢？例如：对于图2所示的结点E，如何区分其lchild的指向的结点J是其左孩子还是前驱结点呢？

为了解决这一问题，现需要添加标志位ltag，rtag。并定义规则如下：

ltag为0时，指向左孩子，为1时指向前驱 rtag为0时，指向右孩子，为1时指向后继

添加ltag和rtag属性后的结点结构如下：

图3

图2所示线索二叉树转变为下图4所示的二叉树:

图4

线索二叉树结点数据结构#

1
typedef enum pointer_flag
2
{
3
  POINTER_NODE,
4
  POINTER_THREAD
5
} pointer_flag;
6

7
typedef struct tree_node
8
{
9
  char data;
10
  struct tree_node *left_child;
11
  struct tree_node *right_child;
12
  pointer_flag left_flag, right_flag;
13
} tree_node;

中序线索二叉树#

建立#

二叉树中序遍历的方法可以参考大佬的这篇博客，实现线索化的过程就是在中序遍历同时修改结点空指针的指向。

加上头结点#

加上线索的二叉树结构是一个双向链表结构，为了便于遍历线索二叉树，我们为其添加一个头结点，头结点左孩子指向原二叉树的根结点，右孩子指针指向中序遍历的最后一个结点。同时，将第一个结点左孩子指针指向头结点，最后一个结点的右孩子指针指向头结点。

图4所示线索二叉树添加头结点后如图5所示：

图5

代码实现#

采用中序遍历的访问顺序实现一棵二叉树的线索化过程代码如下：

1
void mid_order_traverse_build_tree(tree_node *root, tree_node **pre_node)
2
{
3
  if(root != NULL)
4
  {
5
    mid_order_traverse_build_tree(root->left_child, pre_node);
6
    if(root->left_child == NULL)
7
    {
8
      root->left_child = *pre_node;
9
      root->left_flag = POINTER_THREAD;
10
    }
11
    else
12
    {
13
      root->left_flag = POINTER_NODE;
14
    }
15

16
    if((*pre_node)->right_child == NULL)
17
    {
18
      (*pre_node)->right_child = root;
19
      (*pre_node)->right_flag = POINTER_THREAD;
20
    }
21
    else
22
    {
23
      (*pre_node)->right_flag = POINTER_NODE;
24
    }
25
    *pre_node = root;
26
    mid_order_traverse_build_tree(root->right_child, pre_node);
27
  }
28
}
29

30
tree_node* build_thread_binary_tree(tree_node *root)
31
{
32
  tree_node *head_node = (tree_node *)malloc(sizeof(tree_node));
33
  tree_node *pre_node;
34

35
  if(root != NULL)
36
  {
37
    head_node->left_child = root;
38
    pre_node = head_node;
39
    mid_order_traverse_build_tree(head_node->left_child, &pre_node);
40
    head_node->right_child = pre_node;
41
    head_node->right_flag = POINTER_THREAD;
42
    pre_node->right_child = head_node;
43
    pre_node->right_flag = POINTER_THREAD;
44
  }
45
  else
46
  {
47
    head_node->left_child = head_node;
48
    head_node->right_child = head_node;
49
  }
50
  return head_node;
51
}

展开收起

遍历#

带有头结点的中序线索二叉树遍历代码如下：

1
void traverse_thread_binary_tree(tree_node *head_node)
2
{
3
  tree_node *p = head_node->left_child;
4

5
  while(p != head_node)
6
  {
7
    while(p->left_flag == POINTER_NODE)
8
    {
9
      p = p->left_child;
10
    }
11
    printf("%c ", p->data);
12
    while(p->right_flag == POINTER_THREAD && p->right_child != head_node)
13
    {
14
      p = p->right_child;
15
      printf("%c ", p->data);
16
    }
17
    p = p->right_child;
18
  }
19
  printf("\n");
20
}

展开收起

先序线索二叉树#

先序线索二叉树在建立时，除了建立的顺序不一样，其他和中序的一样，这里，我就偷个懒，只贴个代码参考。

先序线索二叉树的建立：

1
void pre_order_traverse_build_tree(tree_node *root, tree_node **pre_node)
2
{
3
  if(root != NULL)
4
  {
5
    if(root->left_child == NULL)
6
    {
7
      root->left_child = *pre_node;
8
      root->left_flag = POINTER_THREAD;
9
    }
10
    else
11
    {
12
      root->left_flag = POINTER_NODE;
13
    }
14

15
    if((*pre_node)->right_child == NULL)
16
    {
17
      (*pre_node)->right_child = root;
18
      (*pre_node)->right_flag = POINTER_THREAD;
19
    }
20
    else
21
    {
22
      (*pre_node)->right_flag = POINTER_NODE;
23
    }
24
    *pre_node = root;
25

26
    if(root->left_flag == POINTER_NODE)
27
    {
28
      pre_order_traverse_build_tree(root->left_child, pre_node);
29
    }
30
    pre_order_traverse_build_tree(root->right_child, pre_node);
31
  }
32
}
33

34
tree_node* build_thread_binary_tree(tree_node *root)
35
{
36
  tree_node *head_node = (tree_node *)malloc(sizeof(tree_node));
37
  tree_node *pre_node;
38

39
  if(root != NULL)
40
  {
41
    head_node->left_child = root;
42
    pre_node = head_node;
43
    pre_order_traverse_build_tree(head_node->left_child, &pre_node);
44
    head_node->right_child = pre_node;
45
    head_node->right_flag = POINTER_THREAD;
46
    pre_node->right_child = head_node;
47
    pre_node->right_flag = POINTER_THREAD;
48
  }
49
  else
50
  {
51
    head_node->left_child = head_node;
52
    head_node->right_child = head_node;
53
  }
54
  return head_node;
55
}

展开收起

先序线索二叉树的遍历：

1
void traverse_thread_binary_tree(tree_node *head_node)
2
{
3
  tree_node *p = head_node->left_child;
4

5
  while(p != head_node)
6
  {
7
    while(p->left_flag == POINTER_NODE)
8
    {
9
      printf("%c ", p->data);
10
      p = p->left_child;
11
    }
12
    printf("%c ", p->data);
13
    p = p->right_child;
14
  }
15
  printf("\n");
16
}

展开收起

后序线索二叉树#

后序线索二叉树是不完善的，要对它进行遍历，还需要使用栈来辅助，这里就不讲了。

结语#

线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。

操作系统学习笔记

Thu, 22 Jul 2021 00:00:00 GMT

操作系统的基本概念#

操作系统的概念#

操作系统：是一些程序集合，这些程序需要：

控制和管理整个计算机系统的硬件与软件资源。
合理地组织、调度计算机的工作与资源分配。
为用户和其他软件提供方便接口与环境。

操作系统的特征#

操作系统的4个基本特征：并发、共享、虚拟、异步。

并发#

并发是指两个或多个事件在同一时间间隔内发生。

操作系统的并发性是指计算机系统中同时存在多个运行的程序，引入进程的目的是使程序能并发执行。

并行性是指系统具有同时进行运算或操作的特性，能在同一时刻完成两种或两种以上的工作。

并行性需要有相关硬件的支持，如多流水线或多处理机环境。

注意同一时间间隔（并发）和同一时刻（并行）的区别。

在多道程序环境下，一段时间内，宏观上有多道程序同时执行，而在每个时刻，单处理机环境下实际仅能有一道程序执行，因此微观上这些程序是分时交替执行的。操作系统的并发性是通过分时得以实现的。

共享#

共享指的是系统中的资源可供内存中多个并发执行的进程共同使用。

共享的两种方式：

互斥共享：一段时间内只运行一个进程访问资源。互斥共享要求一种资源在一段时间内只能满足一个请求，只有当前请求完成后才能处理下一个请求。
同时访问：一段时间内由多个进程同时访问资源。同时访问共享允许一个请求分成几个时间片段间隔地完成，在时间片段间隔之间，资源可以被其他请求访问。同时访问共享在当前请求没有完成时，也能处理其他请求，并且其效果与连续完成的效果相同。

临界资源：一段时间内只允许一个进程访问的资源。

并发和共享是操作系统的两个最基本特征，两者之间互为存在的条件：

资源共享是以程序的并发为条件的，若系统不允许程序并发执行，则自然不存在资源共享问题。
若系统不能对资源共享实施有效的管理，则必将影响到程序的并发执行，甚至根本无法并发执行。

虚拟#

虚拟是指把一个物理上的实体变为若工逻辑上的对应物。

用于实现虚拟的技术，称为虚拟技术。

操作系统中利用了多种虚拟技术来实现虚拟处理器、虚拟内存和虚拟外部设备等。

虚拟处理器技术：通过多道程序设计技术，采用让多道程序并发执行的方法，来分时使用同一处理器。 虚拟处理器：利用多道程序设计技术，把一个物理上的CPU虚拟为多个逻辑上的CPU。

虚拟存储器技术：将一台机器的物理存储器变为虚拟存储器，以便从逻辑上扩充存储器的容量。虚拟存储器：逻辑上的存储器。

操作系统的虚拟技术可归纳为：时分复用技术，如处理器的分时共享；空分复用技术，如虚拟存储器。

异步#

进程的异步：多道程序允许多个程序并发执行，但由于资源有限，进程的执行并不是一贯到底的，而是走走停停的，以不可预知的速度向前推进。

操作系统的目标和功能#

操作系统作为计算机系统资源的管理者#

处理机管理：对进程的管理。进程管理的最主要任务：进程何时创建、何时撤销、如何管理、如何避免冲突、如何共享。进程管理的主要功能：进程控制、进程同步、进程通信、死锁处理、处理机调度等。

存储器管理：主要包括内存分配与回收、地址映射、内存保护与共享和内存扩充等功能。

文件管理：操作系统中负责文件管理的部分称为文件系统。文件管理包括文件存储空间的管理、目录管理、文件读写管理和保护等。

设备管理：主要任务是完成用户的IO（输入输出）请求，方便用户使用各种设备，并提高设备的利用率。主要包括缓冲管理、设备分配、设备处理和虚拟设备等功能。

操作系统作为用户与计算机硬件系统之间的接口#

操作系统提供的接口主要分为两类：命令接口、程序接口。

命令接口：主要方式有两种：

联机命令接口：又称交互式命令接口，由一组键盘操作命令组成。用户通过终端输入操作命令，向系统提出各种服务要求。
脱机命令接口：又称批处理命令接口，由一组控制命令组成。用户事先用相应的作业控制命令写成一份作业操作说明书，连同作业一起提交给系统，系统调度到改作业时，由系统中的命令解释程序逐条解释执行作业说明书上的命令。

程序接口：由一组系统调用（也称广义指令）组成。用户通过在程序中使用这些系统调用来请求操作系统为其提供服务。库函数是高级语言中提供的与系统调用对应的函数，但是库函数属于用户程序而非系统调用，是系统调用的上层。

操作系统用作扩充机器#

裸机：没有任何软件支持的计算机。通常把覆盖了软件的机器称为扩充机器或虚拟机。

操作系统课程所关注的内容是操作系统如何控制和协调处理机、存储器、设备和文件，而不关注接口和扩充机器。

操作系统的发展和分类#

手工操作阶段#

此阶段无操作系统，用户在计算机上的工作都要人工干预。

缺点：资源利用率低，CPU等待手工操作，CPU利用不充分。

批处理阶段#

单道批处理阶段#

特征：

单道性：内存中仅有一道程序运行。
顺序性：磁带上的各道作业顺序地进入内存，先调入内存的作业先完成。
自动性：磁带上的一批作业能自动地逐个运行。

缺点：每次主机内存中仅能存放一道作业，当主机在运行期间发出输入/输出请求后，高速的CPU便处于等待低速的IO完成的状态。

多道批处理系统#

多道程序设计技术允许多个程序同时进入内存，并允许它们在CPU中交替地运行，这些程序共享系统中的各种硬/软件资源。特点是多道、宏观上并行、微观上串行。

多道：内存中同时存放多道相互独立的程序。
宏观上并行：内存中的多道程序都处于运行过程中。
微观上串行：内存中的多道程序轮流占用CPU，交替执行。

需要解决的问题：

如何分配处理器。
多道程序的内存分配问题。
IO设备分配问题。
如何组织和存放大量的程序和数据，以方便用户使用并保证其安全性与一致性。

多道批处理系统把用户提交的作业成批地送入计算机内存，然后由作业调度程序自动地选择作业运行。

优点：资源利用率高，系统吞吐量大。

缺点：用户响应时间较长，不提供人机交互能力。

分时操作系统#

分时技术：把处理器的运行时间分成很短的时间片，按时间片轮流把处理器分配给各联机作业使用。

分时操作系统：多个用户通过终端同时共享一台主机，这些终端连接在主机上，用户可以同时与主机进行交互操作而互不干扰。

分时操作系统的特征：

同时性：也称多路性，指运行多个终端用户同时或基本同时使用同一台计算机。
交互性：用户能通过中端，采用人机对话的方式直接控制程序的运行，与程序进行交互。
独立性：系统中的多个用户可以彼此独立地进行操作，互不干扰。
及时性：用户请求能在很短时间内获得响应。

实时操作系统#

实时操作系统：能在某个时间限制内完成某些紧急任务而不需要时间片等待。

硬实时操作系统：某个动作必须绝对地在规定的时刻（或规定的时间范围）发生。
软实时操作系统：能够接受偶尔违反时间规定且不会引起任何永久性的损害。

网络操作系统#

把计算机网络中的各台计算机有机地结合起来，提供一种统一、经济而有效的使用各台计算机的方法，实现各台计算机之间数据的互相传送。

分布式计算机系统#

分布式计算机系统是由多台计算机组成并满足下列条件的系统：

系统中任意两台计算机通过通信方式交互信息；
系统中的每台计算机都具有同等的地位，既没有主机也没有从机；
每台计算机上的资源为所有用户共享；
系统中的任意台计算机都可以构成一个子系统，并且还能重构；
任何工作都可以分布在机台计算机上，由它们并行工作、协同完成。

用于管理分布式计算机的操作系统称为分布式计算机系统。该系统的主要特点是：分布性和并行性。分布式操作系统与网络操作系统的本质不同是，分布式操作系统中的若干计算机相互协同完成同一任务。

个人计算机操作系统#

个人计算机系统是目前使用最广泛的操作系统，常见的有Windows、Linux和Macintosh等。

操作系统的发展历程：

操作系统的运行环境#

操作系统的运行机制#

通常CPU执行两种不同性质的程序：一种是操作系统内核程序；另一种是用户自编的程序（系统外层的应用程序）。系统内核程序是应用程序的管理者，可以执行一些特权指令，比如IO指令、置中断指令、存取用于内存保护的寄存器、送程序状态字到程序状态字寄存器等，特权指令不允许用户直接使用。CPU的状态可以分为用户态（目态）和核心态（又称管态、内核态），CPU只能在核心态时运行特权指令，用户自编程序运行在用户态，操作系统内核程序运行在核心态。

操作系统的各项功能分别被设置在不同的层次上。一些与硬件关联较紧密的模块，如时钟管理、中断处理、设备驱动等处于最底层。其次是运行频率较高的程序，如进程管理、存储器管理和设备管理等。这两部分内容构成了操作系统的内核，工作在核心态。

内核是计算机上配置的底层软件，大部分操作系统内核包括4方面的内容。

时钟管理#

在计算机各部件中，时钟是最关键的设备。操作系统需要通过时钟管理，向用户提供标准的系统时间，通过时钟中断的管理，可以实现进程的切换。

中断机制#

中断是操作系统各项操作的基础，在中断机制中，只有一小部分功能属于内核，它们负责保护和恢复中断现场的信息，转移控制权到相关的处理程序。

原语#

特点：

处于操作系统的最底层，是最接近硬件的部分。
这些程序的运行具有原子性，其操作只能一气呵成。
这些程序的运行时间都较短，而且调用频繁。

通常把具有这些特点的程序称为原语。定义原语的直接方法是关闭中断，让其所有动作不可分割地完成后再打开中断。

系统控制的数据结构及处理#

系统的一些基本操作：

进程管理：进程状态管理、进程调度和分派、创建与撤销进程控制块等。
存储器管理：存储器的空间分配和回收、内存信息保护程序、代码对换程序等。
设备管理：缓冲区管理、设备分配和回收等。

中断和异常的概念#

中断和异常的定义#

中断：也称外中断，指来自CPU执行指令以外的事件的发生，如设备发出的IO结束中断，时钟中断。

异常：也称内中断、例外或陷入，指源自CPU执行指令内部的事件，如程序的非法操作码、地址越界、算术溢出等引起的事件。

中断处理的过程#

关中断。CPU响应中断后，首先要保护程序的现场状态，在保护现场的过程中，CPU不应该响应更高级中断源的请求。否则，若现场保存不完整，在中断服务程序结束后，也就不能正确地恢复并继续执行现场程序。
保存断点。为保证中断服务程序执行完毕后能正确地返回到原来的程序，必须将原来的程序断点（即程序计数器PC指针）保存起来。
引出中断服务程序。其实质是取出中断服务程序的入口地址送入程序计数器PC中。
保存现场和屏蔽字。进入中断服务程序后，首先要保存现场，现场信息一般是指程序状态字寄存器PSWR和某些通用寄存器的内容。
开中断。允许更高级中断请求得到响应。
执行中断服务程序。字面意思，执行中断服务程序。
关中断。保证在恢复现场和屏蔽字时不被中断。
开中断、中断返回。中断服务程序的最后一条指令通常是一条中断返回指令，使其返回到原程序的断点处，以便继续执行原程序。

1～3步是在CPU进入中断周期后，由硬件自动（中断隐指令）完成的，4～9步由中断服务程序完成。

系统调用#

系统调用是指用户在程序中调用操作系统所提供的一些子功能，系统调用可视为特殊的公共子程序。系统中的各种共享资源都由操作系统统一掌管，因此在用户程序中，凡是与资源有关的操作（如存储分配、进行IO传输及管理文件等），都必须通过系统调用方式向操作系统提出服务请求，并由操作系统代为完成。

系统调用的功能大致可分为如小几类：

设备管理。完成设备的请求和释放，以及设备启动等功能。
文件管理。完成文件的读、写、创建及删除等功能。
进程控制。完成进程的创建、撤销、阻塞及唤醒等功能。
进程通信。完成进程之间的消息传递或信号传递等功能。
内存管理。完成内存的分配、回收以及获取作业占用内存区大小及起始地址等功能。

系统调用执行过程

用户程序可以执行陷入指令（又称访管指令或trap指令）来发起系统调用，请求操作系统提供服务。

操作系统的体系结构#

大内核和微内核#

大内核：操作系统的主要功能模块都作为一个紧密联系的整体运行在核心态，从而为应用提供高性能的系统服务。优点：性能高。缺点：大型操作系统设计比较复杂，内核代码难以维护。

微内核：将内核中最基本的功能保留在内核，将不需要在核心态执行的功能移到用户态执行，从而降低内核的设计复杂性。优点：有效地分离了内核与服务、服务与服务，使得它们之间的接口更加清晰，维护的成本大大降低。缺点：需要频繁地在核心态和用户态之间进行切换，操作系统的开销偏大。

疑难点#

并性与并发的区别和联系#

并行性，指两个或多个事件在同一时刻发生。并发性，指两个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内，宏观上有多个程序同时运行，但在单处理器系统中每个时刻却仅能有一道程序执行，因此微观上这些程序只能分时地交替执行。

特权指令和非特权指令#

特权指令，值有特殊权限的指令。由于这类指令的权限最大，使用不当将导致整个系统崩溃，如清内存、置时钟、分配系统资源、修改虚拟内存的段表和页表、修改用户的访问权限等。为保证系统安全，这类指令只能用于操作系统或其他系统软件，不直接提供给用户使用。特权指令必须在核心态执行。

用户态下也能执行的指令叫非特权指令，在用户态下使用特权指令时，将产生中断以阻止用户使用特权指令。从用户态转换为核心态的唯一途径是中断或异常。

访管指令和访管中断#

访管指令是一条可以在用户态下执行的指令。在用户程序中，因要求操作系统提供服务而有意识地使用访管指令，从而产生一个中断事件（自愿中断），将操作系统转换为核心态，称为访管中断。

进程与线程#

进程的概念和特征#

进程的概念#

比较典型的进程定义：

进程是程序的一次执行过程。
进程是一个程序及数据在处理机上顺序执行时所发生的活动。
进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

进程控制块：（Process Control Block，PCB）为了使进程能独立地并发运行，而专门配置的数据结构。

进程的特征#

动态性。进程是程序的一次执行，它有着创建、活动、暂停、终止等过程，具有一定的生命周期，是动态产生、变化和消亡的。动态性是进程最基本的特征。
并发性。指多个进程实体同时存于内存中，能在一段时间内同时运行。并发性是进程的重要特征，同时也是操作系统的重要特征。引入进程的目的就是为了使程序能与其他进程的程序并发执行，一提高资源利用率。
独立性。指进程实体是一个能独立运行、独立获得资源和独立接受调度的基本单位。凡是未建立PCB的程序，都不能作为一个独立的单位参与运行。
异步性。由于进程的相互制约，使得进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进。异步性会导致执行结果的不可再现性，为此在操作系统中必须配置相应的进程同步机制。
结构性。每个进程都配置一个PCB对其进行描述。从结构上看，进程实体是由程序段、数据段和进程控制块三部分组成的。

进程的状态与转换#

通常进程有以下五种状态，前三种是进程的基本状态。

运行态。进程正在处理机上运行。在单处理机环境下，每个时刻最多只有一个进程处于运行态。
就绪态。进程获得了处理机外的一切所需资源，一旦得到处理机，便可立即运行。系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列。
阻塞态。又称等待态。进程正在等待某一事件而暂停运行，如等待某资源为可用（不包括处理机）或等待输入/输出完成。即使处理机空闲，该进程也不能运行。
创建态。进程正在被创建，尚未转到就绪态。创建进程通常需要多个步骤：首先申请一个空白的PCB，并向PCB中填写一些控制和管理进程的信息；然后由系统为该进程分配运行时所需的资源；最后把该进程转入就绪态。
结束态。进程正在从系统中消失，可能是进程正常结束或其他原因中断退出运行。进程需要结束运行时，系统首先必须置改进程为结束态，然后再进一步处理资源释放和回收等工作。

注意区别就绪态和阻塞态：就绪态是指进程仅缺少处理机，只要获得处理机资源就立即运行；而阻塞态是指进程需要其他资源（除了处理机）或等待某一事件。之所以把处理机和其他资源划分开，是因为在分时系统的时间片轮转机制中，每个进程分到的时间片是若干毫秒，进程得到处理机的时间很短且非常频繁，进程在运行过程中实际上是频繁地转换到就绪态的；而其他资源（如外设）的使用和分配或某一事件的发生（如IO操作的完成）对应的时间相对来说很长，进程转换到等待态的次数也相对较少。

下图说明了进程5种状态的转换：

就绪态 —> 运行态：处于就绪态的进程被调度后，获得处理机资源（分配到了处理时间片），于是进程由就绪态转换为运行态。
运行态 —> 就绪态：处于运行态的进程在时间片用完后，不得不让出处理机，从而进程由运行态转换为就绪态。此外，在可抢占的操作系统中，当有更高优先级的进程就绪时，调度程序将正在执行的进程转换为就绪态，让更高优先级的进程执行。
运行态 —> 阻塞态：进程请求某一资源（如外设）的使用和分配或等待某一事件的发生（如IO操作的完成）时，它就从运行态转换为阻塞态。进程以系统调用的形式请求操作系统提供服务。
阻塞态 —> 就绪态：进程等待的事件到来时，如IO操作结束或中断结束时，中断处理程序必须把相应进程的状态由阻塞态转换为就绪态。

一个进程从运行态变成阻塞态是主动行为，而从运行态变成就绪态是被动行为。

进程控制#

进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态装换等功能。在操作系统中，一般把进程控制用的程序段称为原语，原语的特点是执行期间不允许中断。

进程的创建#

允许一个进程创建另一个进程。此时创建者称为父进程，被创建的进程称为子进程。子进程可以继承父进程所拥有的资源。当子进程被撤销时，应将其从父进程那里获得的资源归还给父进程。此外，在撤销父进程时，必须同时撤销其所有的子进程。

操作系统创建一个新进程的过程如下（创建原语）：

为新进程分配一个唯一的进程标识号，并申请一个空白的PCB（PCB是有限的）。若PCB申请失败，则创建失败。
为进程分配资源，为新进程的程序和数据及用户栈分配必要的内存空间（在PCB中体现）。若资源不足（如内存空间），则并不是创建失败，而是处于阻塞态，等待内存资源。
初始化PCB，主要包括初始化标志信息、初始化处理机状态信息和初始化处理机控制信息，以及设置进程的优先级等。
若进程就绪队列能够接纳新进程，则将新进程插入就绪队列，等待被调度运行。

进程的终止#

引起进程终止的事件：

正常结束，表示进程的任务已完成并准备退出运行。
异常退出，表示进程在运行时，发生了某种异常事件，使程序无法继续运行。
外界干预，指进程应外界的请求而终止运行，如操作员或操作系统干预、父进程请求和父进程终止。

操作系统终止进程的过程（撤销原语）：

根据被终止进程的标识符，检索PCB，从中读出该进程的状态。
若被终止进程处于执行状态，立即终止该进程的执行，将处理机资源分配给其他进程。
若该进程还有子孙进程，则应将其所有子孙进程终止。
将该进程所拥有的全部资源，或归还给其父进程，或归还给操作系统。
将该PCB从所在队列中删除。

进程的阻塞和唤醒#

阻塞原语的执行过程：

找到要被阻塞进程的标识号对应的PCB。
若进程为运行态，则保护其现场，将处理机资源调度给其他就绪进程。
把该PCB插入相应事件的等待队列，将处理机资源调度给其他就绪进程。

唤醒原语的执行过程：

在该事件的等待队列中找到相应进程的PCB。
将其从等待队列中移出，并置其状态为就绪态。
把该PCB插入就绪队列，等待调度程序调度。

进程切换#

进程切换的过程：

保存处理机上下文，包括程序计数器和其他寄存器。
更新PCB信息。
把进程的PCB移入相应的队列，并更新其PCB。
选择另一个进程执行，并更新其PCB。
更新内存管理的数据结构。
恢复处理机上下文。

注意调度和切换的区别。调度是指决定资源分配给哪个进程的行为，是一种决策行为；切换是指实际分配的行为，是执行行为。一般来说，先有资源的调度，然后才有进程的切换。

进程的组织#

进程是一个独立运行单位，也是操作系统进行资源分配和调度的基本单位。它由以下三部分组成，其中最核心的是进程控制块（PCB）。

进程控制块#

进程创建时，操作系统为它新建一个PCB，该结构之后常驻内存，任意时刻都可以存取，并在进程结束时删除。PCB是进程实体的一部分，是进程存在的唯一标志。

进程执行时，系统通过其PCB了解进程的现行状态信息，以便对其进行控制和管理；进程结束时，系统收回其PCB，该进程随之消亡。操作系统通过PCB表来管理和控制进程。

当操作系统欲调度某进程运行时，要从该进程的PCB中查出其现行状态及优先级；在调度到某进程后，需要根据其PCB中所保存的处理机状态信息，设置该进程恢复运行的现场，并根据其PCB中的程序和数据的内存地址，找到其程序和数据；进程在运行过程中，当需要和与之合作的进程实现同步、通信或访问文件时，也需要访问PCB；当进程由于某种原因而暂停运行时，又需将其断点的处理机环境保存在PCB中。

在进程的整个生命期中，系统总是通过PCB对进程进行控制的，亦即系统唯有通过进程的PCB才能感知到该进程的存在。

PCB通常包含的内容：

进程描述信息	进程控制和管理信息	资源分配清单	处理机相关信息
进程标识符（PID）	进程当前状态	代码段指针	通用寄存器值
用户标识符（UID）	进程优先级	数据段指针	地址寄存器值
	代码运行入口地址	堆栈段指针	控制寄存器值
	程序的外存地址	文件描述符	标志寄存器值
	进入内存的时间	键盘	状态字
	处理机占用时间	鼠标
	信号量使用

进程描述信息：

进程标识符：标志各个进程，每个进程都有一个唯一的标识符。
用户标识符：进程归属的用户，用户标识符主要为共享和保护服务。

进程控制和管理信息：

进程当前状态：描述进程的状态信息，作为处理机分配调度的依据。
进程优先级：描述进程抢占处理机的优先级，优先级高的进程可优先获得处理机。

资源分配清单：用于说明有关内存地址空间或虚拟地址空间的状况，所打开文件的列表和所使用的输入输出设备信息。

处理机相关信息：主要指处理机中各寄存器的值，当进程被切换时，处理机状态信息都必须保存在相应的PCB中，以便在该进程重新执行时，能从断点继续执行。

程序段#

程序段就是能被进程调度程序调度到CPU执行的程序代码段。程序可被多个进程共享，即多个进程可以运行同一个程序。

数据段#

一个进程的数据段，可以是进程对应的程序加工处理的原始数据，也可以是程序执行时产生的中间或最终结果。

进程的通信#

共享存储#

在通信的进程之间存在一块可直接访问的共享空间，通过对这片共享空间进行写/读操作实现进程之间的信息交换。在对共享空间进行写/读操作时，需要使用同步互斥工具（如P操作、V操作），对共享空间的写/读进行控制。共享存储分为两种：低级方式的共享是基于数据结构的共享；高级方式的共享则是基于存储区的共享。操作系统只负责为通信进程提供可共享使用的存储空间和同步互斥工具，而数据交换则由用户自己安排读/写指令完成。

消息传递#

在消息传递系统中，进程间的数据交换是以格式化的消息为单位的。进程通过系统提供的发送消息和接收消息两个原语进行数据交换。

直接通信方式。发送进程直接把消息发送给接收进程，并将它挂在接收进程的消息缓冲队列上，接收进程从消息缓冲队列中取得消息。
间接通信方式。发送进程把消息发送到某个中间实体，接收进程从中间实体取得消息。这种中间实体一般称为信箱，这种通信方式又称信箱通信方式。该通信方式广泛应用于计算机网络中，相应的通信系统称为电子邮件系统。

管道通信#

管道是指用于连接一个读进程和一个写进程以实现它们之间通信的一个共享文件，又名pipe文件。向管道提供输入的发送进程（即写进程），以字符流形式将大量数据送入（写）管道；而接收管道输出的接收进程（即读进程）则从管道中接收（读）数据。为了协调双方的通信，管道机制必须提供三方面的协调能力：互斥、同步和确定对方的存在。

从管道读数据是一次性操作，数据一旦被读取，它就从管道中被抛弃，释放空间以便写更多的数据。管道只能采用半双工通信，即某一时刻只能单向传输。要实现进程双方互动通信，需要定义两个管道。

线程概念和多线程模型#

线程的基本概念#

线程最直接的理解就是”轻量级进程”，它是一个基本的CPU执行单元，也是程序执行流的最小单元，由线程ID、程序计数器、寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。

引入线程后，进程的内涵发生了改变，进程只作为除CPU外的系统资源分配单元，而线程则作为处理机的分配单元。由于一个进程内部有多个线程，若线程的切换发生在同一个进程内部，则只需要很少的时空开销。

线程与进程的比较#

调度。在传统的操作系统中，拥有资源和独立调度的基本单位都是进程。在引入线程的操作系统中，线程是独立调度的基本单位，进程是拥有资源的基本单位。
拥有资源。不论是传统操作系统还是设有线程的操作系统，进程都是拥有资源的基本单位，而线程不拥有系统资源（也有一点必不可少的资源），但线程可以访问其隶属进程的系统资源。
并发性。在引入线程的操作系统中，不仅进程之间可以并发执行，而且多个线程之间也可以并发执行，从而使操作系统具有更好的并发性，提高了系统的吞吐量。
系统开销。由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、IO设备等，因此操作系统所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程CPU环境的保存及新调度到进程CPU环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。此外，由于同一进程内的多个线程共享进程的地址空间，因此这些线程之间的同步与通信非常容易实现，甚至无须操作系统的干预。
地址空间和其他资源。进程的地址空间之间互相独立，同一进程的各线程间共享进程的资源，某进程内的线程对于其他进程不可见。
通信方面。进程间通信（IPC）需要进程同步和互斥手段的辅助，以保证数据的一致性，而线程间可以直接读/写进程数据段（如全局变量）来进行通信。

线程的属性#

线程是一个轻型实体，它不拥有系统资源，但每个线程都应有一个唯一的标识符和一个线程控制块，线程控制块记录了线程执行的寄存器和栈等现场状态。
不同的线程可以执行相同的程序，即同一个服务程序被不同的用户调用时，操作系统把它们创建成不同的线程。
同一个进程中的各个线程共享该进程所拥有的资源。
线程是处理机的独立调度单位，多个线程是可以并发执行的。
一个线程被创建后，便开始了它的生命周期，直至终止。线程在生命周期内会经历阻塞态、就绪态和运行态等各种状态变化。

线程的实现方式#

线程的实现可以分为两类：用户级线程（User-Level Thread，ULT）和内核级线程（Kernel-Level Thread，KLT），内核级线程又称内核支持的线程。

在用户级线程中，有关线程管理（线程的创建、撤销和切换等）的所有工作都由应用程序完成，内核意识不到线程的存在。应用程序可以通过使用线程库设计成多线程程序。

在内核级线程中，线程管理的所有工作由内核完成，应用程序没有进行线程管理的代码，只有一个到内核级线程的编程接口。内核为进程及其内部的每个线程维护上下文信息，调度也在内核基于线程架构的基础上完成。

有些系统中使用组合方式的多线程实现。线程的创建完全在用户空间中完成，线程的调度和同步也在应用程序中进行。一个应用程序中的多个用户级线程被映射到一些（小于等于用户级线程的数目）内核级线程上。

多线程模型#

多对一模型。将多个用户级线程映射到一个内核级线程，线程管理在用户空间完成。此模式中，用户级对操作系统不可见（即透明）。
- 优点：线程管理是在用户空间进行的，因而效率比较高。
- 缺点：一个线程在使用内核服务时被阻塞，整个进程都会被阻塞；多个线程不能并行地运行在多处理机上
一对一模型。将每个用户级线程映射到一个内核级线程。
- 优点：当一个线程被阻塞后，允许另一个线程继续执行，所以并发能力较强。
- 缺点：每创建一个用户级线程都需要创建一个内核级线程与其对应，这样创建线程的开销比较大，会影响到应用程序的性能。
多对多模型。将n个用户级线程映射到m个内核级线程上，要求m≤nm \leq nm≤n。
- 特点：多对多模型是多对一模型和一对一模型的折中，即克服了多对一模型并发度不高的缺点，又克服了一对一模型的一个用户进程占用太多内核级线程而开销太大的缺点。此外，还拥有多对一模型和一对一模型各自的优点。

处理机调度#

调度的概念#

调度的基本概念#

处理机调度是对处理机进行分配，即从就绪队列中按照一定的算法（公平＼高效）选择一个进程，并将处理机分配给它运行，以实现进程并发地执行。

调度的层次#

作业调度。又称高级调度，其主要任务是按一定的原则从外存上处于后备状态的作业中挑选一个（或多个）作业，给它们分配内存、输入/输出设备等必要的资源，并建立相应的进程，以使它们获得竞争处理机的权利。作业调度是内存与辅存之间的调度。对于每个作业只调入一次、调出一次。
中级调度。又称内存调度，其作用是提高内存利用率和系统吞吐量。为此，应将那些暂时不能运行的进程调至外存等待，把此时的进程状态称为挂起态。当它们已具备运行条件且内存又稍有空闲时，由中级调度来决定把外存上那些已具备运行条件的就绪进程，再重新调入内存，并修改其状态为就绪态，挂在就绪队列上等待。

做了一个点阵屏

Fri, 16 Jul 2021 00:00:00 GMT

先说两句#

~~最近上班摸鱼太无聊了，~~因为和某人约定好了要送一个礼物，又因为最近做嵌入式的原因，有点手痒，想自己做个东西玩玩，所以打算开始做个点阵屏。然后前阵子学了一下kicad，打算拿这个练手，算是我第一次画电路板。感觉和大佬比起来，我这就像过家家一样🙃。

MAX7219芯片#

因为没学过硬件，画电路板没一点头绪，所以就花了5块钱从淘宝上买了一个8×8的点阵屏，打算抄参考一下，买来以后是这样的：

感觉比我想像的要简单一点，就一个芯片、一个点阵屏、一个电容和一个电阻。去找商家要了一下资料（下载链接），后来才知道这个芯片叫MAX7219。扫了一眼MAX7219的芯片手册，没怎么看懂🙃，结合资料里的样例代码才勉强看懂了一点点。

硬件方面#

MAX7219一共有24个引脚，各个引脚的功能如下表：

管脚	名称	功能描述
1	DIN	串行数据输入端口。在时钟上升沿时数据被载入内部的16位寄存器。
2,3,5-8,10,11	DIG0–DIG7	八个数据驱动线路置显示器共阴极为低电平。关闭时此管脚输出高电平。
4,9	GND	地线(4 脚和 9 脚必须同时接地)
12	LOAD	载入数据。连续数据的后16位在LOAD端的上升沿时被锁定。
13	CLK	时钟序列输入端。最大速率为10MHz.在时钟的上升沿,数据移入内部移位寄存器。下降沿时,数据从DOUT端输出。
14-17,20-23	SEGA-SEGG,DP	7段和小数点驱动,为显示器提供电流。当一个段驱动关闭时,此端呈低电平
18	SET	通过一个电阻连接到 VDDV_{DD}VDD 来提高段电流。
19	V+V_{+}V+	正极电压输入，+5V（好像3.3V）也可以
24	DOUT	串行数据输出端口,从DIN输入的数据在16.5个时钟周期后在此端有效。当使用多个MAX7219时用此端方便扩展。

然后8×8的点阵屏模块MAX7219部分的原理图是这样的：

按照原理图，MAX7219的DIG0–DIG7接点阵屏的共阴极，SEGA-SEGG和DP接点阵屏的共阳极，DIN、CLK、LOAD接到MCU的IO口上，用来与MCU通信，DOUT接到下一个MAX7219的DIN上，用来实现多个级联。然后其他引脚按照电路图接对应的元件和电源就好了。

软件方面#

控制MAX7219的方式是写寄存器，MAX7219一共有14个8位的可寻址的数据寄存器和控制寄存器，MCU通过给这些寄存器写数据来控制MAX7219的工作。

写移位寄存器#

刚刚说到，MAX7219有3个引脚（DIN、CLK、LOAD）是接到MCU的IO口上的，写寄存器就是通过这3个引脚来完成的。在MAX7219里有一个16位的移位寄存器，当CLK引脚出现一个上升沿的电压信号后，MAX7219就会将DIN端的信号移入移位寄存器里，作为移位寄存器的最后一位。

举个栗子，下图中在CLK的第1个上升沿，MCU给了DIN一个高电平，所以MAX7219的移位寄存器移入了一个1，然后在CLK的第2个上升沿，MCU给了DIN一个低电平，所以MAX7219的移位寄存器移入了一个0。最终的效果就是移位寄存器里原来的数据向前移动了两位，后两位数据变成了移入的1和0。

按照上面说的方法，连续写16位数据，就可以把移位寄存器写成我们想要的数据了。

写内部寄存器#

数据写入移位寄存器之后，就可以利用移位寄存器的数据来更改MAX7219的14个数据寄存器和控制寄存器（以下简称为内部寄存器）了。

移位寄存器的数据可以分成两个部分，一部分是用来表示内部寄存器的地址，占4位，位于第8到第11位，一部分是用来表示寄存器的数据，位于第0到第7位，如下图所示：

当MCU给LOAD引脚一个上升沿信号时，MAX7219就根据移位寄存器中的4个地址位，选择对应的内部寄存器，然后把移位寄存器里的8个数据位写入该寄存器中。

结合之前的写移位寄存器的方法，就可以实现将数据据写入对应的内部寄存器中了。这里给出一个用来写内部寄存器的参考代码：

1
/**
2
 * @brief : 向MAX7219的移位寄存器写入一个字节的数据
3
 * @param data : [in]需要写入的数据
4
 */
5
void write_max7219_byte(unsigned char data)
6
{
7
  int i;
8

9
  for (i = 0; i < 8; i++)
10
  {
11
    write_max7219_pin(CLK_PIN, 0);
12
    if(data & 0x80)
13
    {
14
      write_max7219_pin(DIN_PIN, 1);
15
    }
16
    else
17
    {
18
      write_max7219_pin(DIN_PIN, 0);
19
    }
20
    write_max7219_pin(CLK_PIN, 1);
21
    data = data << 1;
22
  }
23
}
24

25
/**
26
 * @brief : 向MAX7219的内部寄存器写入数据
27
 * @param load_pin : [in]对应MAX7219的LOAD引脚
28
 * @param address : [in]内部寄存器地址
29
 * @param data : [in]需要写入内部寄存器的数据
30
 */
31
void write_max7219_register(max7219_pin_def load_pin, unsigned char address, unsigned char data)
32
{
33
  write_max7219_pin(load_pin, 0);
34
  write_max7219_byte(address);
35
  write_max7219_byte(data);
36
  write_max7219_pin(load_pin, 1);
37
}

展开收起

内部寄存器#

刚刚已经介绍了如何写内部寄存器，接下来就是如何用这14个内部寄存器控制MAX7219工作。这些寄存器分两类，一类是控制寄存器，共5个，分别用来设置编码模式、显示亮度、扫描限制、掉电模式以及显示检测，另一类是数据寄存器，用来设置显示的数据。

地址	寄存器
0x00	不工作寄存器
0x01-0x08	8个数据寄存器
0x09	译码模式寄存器
0x0A	亮度控制寄存器
0x0B	扫描控制寄存器
0x0C	掉电模式寄存器
0x0F	显示检测寄存器

数据寄存器很好理解，共8个，对应8个段选，每个8位，每一位对应SEGA～SEGG和SEGDP八个引脚的输出电平。MAX7219工作时，DIG0～7八个引脚会按顺序输出低电平，同时根据数据寄存器中的值，给SEG八个引脚输出对应的电平。比如，当前DIG引脚输出低电平时，其他DIG引脚都输出高电平，MAX7219就按照第2个数据寄存器（地址是0x03）中的值，给SEG引脚输出对应的电平，下一次就轮到给DIG3引脚输出低电平，按照第3个数据寄存器中的值，给SEG引脚输出对应的电平，如此循环八个引脚。

控制寄存器我没怎么细看，打算直接按照参考的驱动代码设置，如下：

1
/**
2
 * @brief : 初始化MAX7219
3
 * @param load_pin : [in]对应MAX7219的LOAD引脚
4
 */
5
void init_max7219(max7219_pin_def load_pin)
6
{
7
  write_max7219_register(load_pin, 0x09, 0x00); /* 译码方式 */
8
  write_max7219_register(load_pin, 0x0a, 0x03); /* 亮度 */
9
  write_max7219_register(load_pin, 0x0b, 0x07); /* 扫描界限；8个数码管显示 */
10
  write_max7219_register(load_pin, 0x0c, 0x01); /* 掉电模式：0，普通模式：1 */
11
  write_max7219_register(load_pin, 0x0f, 0x00); /* 显示测试：1；测试结束，正常显示：0 */
12
}

按照上面的代码初始化好后，将要显示的内容写入数据寄存器就好了。比如要显示一个字母’A’的代码如下：

1
/**
2
 * @brief : 让点阵屏显示一个A
3
 */
4
void show_a()
5
{
6
  int i;
7
  /* 字母A的点阵数据，1的位置是点阵屏上要亮的位置 */
8
  unsigned char data[8] = {0x08, 0x14, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x22};
9
  /*  16进制         二进制
10
     0x08 ---> 0 0 0 0 1 0 0 0
11
     0x14 ---> 0 0 0 1 0 1 0 0
12
     0x22 ---> 0 0 1 0 0 0 1 0
13
     0x3E ---> 0 0 1 1 1 1 1 0
14
     0x22 ---> 0 0 1 0 0 0 1 0
15
     0x22 ---> 0 0 1 0 0 0 1 0
16
     0x22 ---> 0 0 1 0 0 0 1 0
17
     0x22 ---> 0 0 1 0 0 0 1 0
18
  */
19

20
  init_max7219(CS1_PIN);
21
  for(i = 1; i <= 8; i++)
22
  {
23
    write_max7219_register(CS1_PIN, (unsigned char)i, data[i - 1]);
24
  }
25
}

展开收起

点阵屏#

点阵屏比较容易理解，就是一些led灯组成的点阵。分为共阴极和共阳极两种，共阴极点阵屏的同一行led阴极是连在一起的，同一列的阳极连在一起，而共阳极点阵屏同一行led的阳极是连在一起的，同一列的阴极连在一起。原理图如下（左边是共阳，右边是共阴）：

从点阵屏的正面看，四个边中有个一个边有突起，将那个边向下，这时点阵的行和列就和上图对应了。上图中圆圈里的编号是引脚编号，点阵屏一共有16个引脚，分成两行，按刚刚的方法放好，上面一排的引脚编号从左往右是16、15、…、9，下面一排的引脚编号从左往右是1、2、…、8。

硬件设计#

原理图设计#

看懂了MAX7219和点阵屏的工作原理后，就可以用kicad开始设计电路了。kicad是一个开源的PCB设计软件，用起来感觉不错，而且有中文文档教程，还跨平台，对于我这个新手来说相当友好，想了解的小伙伴可以去kicad的官网看看。

kicad的元件库里有MAX7219，可以直接拿来用，但是没有点阵屏，所以要自己加一个点阵屏元件，下图是我自己加的1088AS元件和封装：

接下来就是设计原理图了，MAX7219部分可以参考资料里的原理图来设计，要做成16×16的点阵的话，需要4个8×8点阵拼接起来，原理图就是下面这样的。

MCU本来打算用STM32F103C8T6的，在淘宝上看了一下，发现最近因为芯片缺货的问题，C8T6涨到了30块钱一片😓…，不过C6T6价格还可以接受，6块一片，而且C6T6的引脚和C8T6的完全一样，用来替代C8T6刚刚好。去网上找了一个STM32F103C8T6最小系统板的资料，参考原理图改了一下，如下：

完整的pdf原理图可以在这里查看。

电路设计#

设计好原理图后开始设计电路。

首先选择封装，所有的电阻和电容都选择0603贴片，两个LED灯用了0805，USB插座想用type-c的，本来想用6PIN的，在kicad里没找到6PIN的封装，干脆就用16PIN的了，都差不多。其他的按照元件的尺寸随便选了一些。

接下来就是让人头大的布线了，唔…，第一次布线，感觉比想像中要难一些，改了很久才搞定，特别是MCU附近的线比较难走线。布好线后是这样的：

kicad里有个3D查看器，可以模拟成品的样子，大概是这个样子的：

左边是正面，右边是背面，因为点阵屏的封装里没有3D模型，所以这个渲染出来就没有点阵屏。

制作#

布好线后，在淘宝上找了个PCB打样的，发现22块钱能打10块板子，感觉还算比较便宜。打样好是这个样子的：

然后把需要的元件都买到后，开始焊板子，感觉比想像中要难焊一点，特别是焊MCU的时候，锡容易把两个引脚粘在一起，用了助焊剂后好了很多。焊好后是这样的：

焊的有点丑，有些电容和电阻歪了。接下来把点阵屏插上去应该就能用了。

写代码#

环境搭建#

用STM32CubeMX生成了一个工程（不清楚的小伙伴可以参考这篇博客），按照电路的连接，配置对应引脚为GPIO上拉输出模式。

接下来生成工程代码，make以后尝试烧录，烧录失败了…。openocd报了下面这个错：

1
> program build/lattice_screen.hex
2
target halted due to debug-request, current mode: Thread
3
xPSR: 0x01000000 pc: 0x08001038 msp: 0x20002800
4
** Programming Started **
5
device id = 0x10006412
6
SWD DPIDR 0x1ba01477
7
Failed to read memory at 0x1ffff7e2
8
STM32 flash size failed, probe inaccurate - assuming 32k flash
9
flash size = 32kbytes
10
stm32x device protected
11
failed erasing sectors 0 to 4
12
embedded:startup.tcl:530: Error: ** Programming Failed **
13
in procedure 'program'
14
in procedure 'program_error' called at file "embedded:startup.tcl", line 595
15
at file "embedded:startup.tcl", line 530

展开收起

一开始还以为是芯片某个引脚没焊好，然后检查一下电路，发现没问题。百度了一下，网上说是因为芯片flash上了锁，要解锁才能烧录，参考了一下大佬的这篇博客，用openocd执行下面的解锁命令后，就可以烧录了。

1
> reset halt
2
target halted due to debug-request, current mode: Thread
3
xPSR: 0x01000000 pc: 0x08001038 msp: 0x20002800
4
> stm32f1x unlock 0
5
stm32x unlocked.
6
INFO: a reset or power cycle is required for the new settings to take effect.
7

8
> reset halt
9
target halted due to debug-request, current mode: Thread
10
xPSR: 0x01000000 pc: 0xfffffffe msp: 0xfffffffc

汉字编码生成#

要显示一个汉字，需要有对应的汉字编码，自己设计比较麻烦，在网上找了一个大佬写的生成16×16汉字点阵的代码。大致的原理是用汉字的GB2312编码，在HZK16字库中，索引到对应的编码，然后打印出来。

显示逻辑#

前面说了8×8点阵屏的显示逻辑，现在是16×16的，也就是4个8×8拼在一起，所以只要让每个8×8显示对应的内容就好了，显示一个汉字的代码如下：

1
/**
2
 * @brief : 让16*16点阵屏显示一个字
3
 */
4
void show_word(unsigned char *word_code)
5
{
6
  int i;
7
  for(i = 0; i < 16; i++)
8
  {
9
    if(i % 2 == 0)
10
    {
11
      write_max7219_register(CS4_PIN, (unsigned char)(i / 2 + 1), word_code[i]);
12
    }
13
    else
14
    {
15
      write_max7219_register(CS2_PIN, (unsigned char)(i / 2 + 1), word_code[i]);
16
    }
17
  }
18
  for(i = 16; i < 32; i++)
19
  {
20
    if(i % 2 == 0)
21
    {
22
      write_max7219_register(CS3_PIN, (unsigned char)(i / 2 - 8 + 1), word_code[i]);
23
    }
24
    else
25
    {
26
      write_max7219_register(CS1_PIN, (unsigned char)(i / 2 - 8 + 1), word_code[i]);
27
    }
28
  }
29
}

展开收起

接下来实现一个字符串的循环移动显示，其实也很简单，只要在一定的延时后，把汉字编码按照一定的逻辑，循环移动一位，然后再把开头显示出来就好了。循环移位的代码如下：

1
/**
2
 * @brief : 将字的编码循环移动一位
3
 * @param word_code : [in/out]字的编码
4
 * @param word_count : [in]字的个数
5
 */
6
void cyclic_shift_word(unsigned char *word_code, int word_count)
7
{
8
  int i, len;
9
  unsigned short front;
10
  unsigned char *p = word_code;
11

12
  front = 0x0000;
13
  for(i = 0; i < 16; i++)
14
  {
15
    if((p[2 * i] & 0x80) != 0)
16
    {
17
      front += (0x0001 << i);
18
    }
19
  }
20
  len = word_count * 32;
21
  for(i = 0; i < len - 32; i++)
22
  {
23
    if(i % 2 == 0)
24
    {
25
      p[i] = (p[i] << 1) + (p[i + 1] >> 7);
26
    }
27
    else
28
    {
29
      p[i] = (p[i] << 1) + (p[i + 31] >> 7);
30
    }
31
  }
32
  for(i = len - 32; i < len; i++)
33
  {
34
    if(i % 2 == 0)
35
    {
36
      p[i] = (p[i] << 1) + (p[i + 1] >> 7);
37
    }
38
    else
39
    {
40
      p[i] = (p[i] << 1) + ((front >> ((i + 31 - len) / 2)) & 0x0001);
41
    }
42
  }
43
}

展开收起

主函数代码：

1
HAL_Delay(2); // 防止MAX7219未正常启动
2
init_screen();
3
while (1)
4
{
5
  show_word(word_code);
6
  cyclic_shift_word(word_code, WORD_COUNT);
7
  HAL_Delay(180);
8
}

成果演示#

虽然点阵屏算是比较简单的一个东西，但是因为是第一次自己画板子，设计电路，感觉还是挺好玩的。

这个点阵屏的硬件设计和代码都已经放到github上了。

ganyuo

lattice_screen

Waiting for api.github.com...

00K

Waiting...

CMSIS-NN: Efficient Neural Network Kernels for Arm Cortex-M CPUs

Wed, 28 Apr 2021 00:00:00 GMT

论文原文下载链接

摘要#

深度神经网络在始终在线的IoT外围设备中变得越来越流行，这些IoT外围设备从源头开始执行数据分析，从而减少了数据通信的延迟和能耗。本文介绍了CMSIS-NN，这些高效的内核经过开发，可在针对智能IoT外围设备的Arm Cortex-M处理器上最大化性能并最小化神经网络（NN）应用程序的内存占用量。基于CMSIS-NN内核的神经网络推理可将运行时间/吞吐量提高4.6倍，将能效提高4.9倍。

介绍#

过去几年中，互联设备（也称为物联网（IoT））迅速增长，预计到2035年在各个市场领域将达到1万亿[1]。这些IoT外围设备通常由收集数据（例如音频，视频，温度，湿度，GPS位置和加速度）的传感器组成，然后进行处理并与其他节点或云进行通信。当前，来自传感器的数据由云中的分析工具进行处理，以实现广泛的应用，例如工业监控，家庭自动化和医疗保健。但是，随着IoT节点数量的增加，这给网络带宽带来了相当大的负担，并给IoT应用程序增加了延迟。此外，对云的依赖使在网络连接受限或不可靠的区域中部署物联网应用程序带来了挑战。解决此问题的一种解决方案是外围计算[2]，它直接在数据源即IoT外围节点上执行，从而减少了等待时间并节省了数据通信的功耗。

在准确性方面，深度神经网络已经证明了在许多复杂的机器学习应用程序中的有接近人的表现，例如图像分类，语音识别和自然语言处理。一个典型的用于图像分类的神经网络（NN）由多层基于卷积的特征提取器组成，然后是用于分类的全连接层，如图1所示。由于计算复杂性和资源需求，神经网络的执行主要限于使用高性能服务器CPU或专用硬件（例如GPU或加速器）进行的云计算，这会增加IoT应用程序的延迟。在数据源即IoT外围处使用小型神经网络进行分类可以减少IoT外设与云之间的数据通信的总体延迟和能耗。

在这项工作中，我们探索了基于资源受限的微控制器平台上神经网络的性能优化，该平台针对智能物联网外围节点。为此，我们开发了优化的软件内核，用于在Arm Cortex-M CPU上部署NN。使用这些软件内核，我们在现成的Arm Cortex-M7平台上演示了针对CIFAR-10数据集的卷积神经网络（CNN），该算法每秒可分类10.1张图像，准确度为79.9％。

概述#

神经网络内核的概述如图2所示。内核代码由两部分组成：NNFunctions和NNSupportFunctions。NNFunctions包含了流行的神经网络层类型的函数实现，例如卷积，深度可分离卷积，全连接（即内积），池化和激活。应用程序代码可以使用这些函数来实现神经网络推理应用程序。内核API也保持简单，因此可以轻松地将它们移植到任何机器学习框架。NNSupportFunctions包括实用程序功能，例如NNFunctions中使用的数据转换和激活函数表。应用程序代码还可使用这些实用程序功能来构建更复杂的NN模块，例如长短期记忆（LSTM）或门控循环单元（GRU）。

对于某些内核，例如全连接和卷积，将实现不同版本的内核函数。提供了一个基本版本，可以对所有层参数普遍使用“原样”。我们还实现了其他版本，其中包括进一步的优化技术，这些技术要么具有转换后的输入，要么对层参数有一些限制。理想情况下，可以使用简单的脚本来解析网络拓扑并自动确定要使用的适当功能。

定点量化#

传统上，使用32位浮点数据表示来训练NN模型。但是，推理期间通常不需要这种高精度。研究表明，即使使用低精度定点表示，神经网络也能很好地运行。定点量化有助于避免昂贵的浮点计算，并减少用于存储权重和激活的内存占用，这对于资源受限的平台至关重要。

尽管不同网络或网络层的精度要求可能会有所不同，但CPU很难对位宽不同的数据类型进行操作。在这项工作中，我们开发了支持8位和16位数据的内核。内核采用与CMSIS中相同的数据类型格式，即q7_tq7\_tq7_t作为int8int8int8，q15_tq15\_tq15_t作为int16int16int16，q31_tq31\_tq31_t作为int32int32int32。假定以2的幂进行定点格式量化，即表示的值将为A×2nA \times 2^nA×2n，其中AAA为整数值，nnn表示小数点位置的整数。我们将偏置的缩放因子传递给内核，并将其作为参数传递给内核，并且由于二次幂缩放，缩放可以用按位移位运算实现。我们使用这种类型的量化（而不是TensorFlow中使用的8位量化）来避免在层之间进行浮点反量化，因为某些Arm Cortex-M CPU可能没有专用的浮点单元（FPU），从而限制了它们的浮点计算能力。这种量化的另一个好处是我们可以使用更简单的基于表查找的激活，这将在第4.5节中讨论。

软件内核#

在本节中，我们描述了提出的软件内核的实现和优化，用于Arm Cortex-M CPU。Cortex-M 系列处理器是32位RISC处理器内核，旨在提高能效，通常用作深度嵌入式应用的微控制器。在这项工作中，我们专注于在支持SIMD指令且基于Cortex-M的系统上启用神经网络，尤其是对NN计算非常有用的16位乘法和累加（MAC）指令（例如SMLAD）。

Support Functions#

大多数NNFunction使用16位MAC指令，因此需要数据转换才能将8位数据类型（即q7_tq7\_tq7_t）转换为16位数据类型（即q15_tq15\_tq15_t）。CMSIS提供了一个实用程序函数arm_q7_to_q15来执行数据转换。图示和伪代码如图3所示。数据转换分为两个步骤：第一步，使用符号扩展指令（__SXTB16）将8位数据扩展为16位数据。第二步重新排列数据，以便输出遵循与输入相同的顺序。

数据转换的性能是至关重要的，因为它被用于计算内核的内部循环。虽然符号扩展的第一步很重要，但是如果两个操作数遵循相同的顺序，则可以省略重新排列数据的第二步。为了更好地利用这一点，我们创建了另一个版本的数据转换例程，而无需对数据进行重新排序，如图4所示。该例程在4.2节中进行了详细讨论。

矩阵乘法#

矩阵乘法是神经网络中最重要的计算内核。这项工作的实现基于CMSIS中的mat_mult内核。与CMSIS实现类似，矩阵乘法内核由2×2内核实现，如图5所示。这可以实现一些数据重用，并节省加载指令的总数。累加是通过q31_t数据类型完成的，两个操作数都是q15_t数据类型。我们用相应的偏置值初始化累加器。使用专用MAC指令__SMLAD执行计算。

卷积#

卷积层通过计算滤波器权重与输入特征图中的小接受域之间的点积来提取新的特征图。通常，基于CPU的卷积实现分解为输入重新排序和扩展（即im2col，image-to-column）和矩阵乘法运算。im2col是将类似图像的输入转换为代表每个卷积滤波器所需数据的列的过程。im2col的示例如图8所示。

im2col的主要挑战之一是增加的内存占用空间，因为在im2col输出矩阵中重复了输入图像中的像素。为了减轻内存占用量的问题，同时保留im2col的性能优势，我们为卷积内核实现了部分im2col。内核将只扩展有限数量的列（例如2列），足以使矩阵乘法内核获得最大的性能提升，同时又使内存开销最小。

图像数据格式也会影响卷积性能，尤其是im2col效率。批处理大小为1时，卷积操作是对3D数据的2D卷积（即卷积窗口可以在两个方向上移动），如图9所示。两种最常见的图像数据格式是“通道-宽-高”（CHW），即通道在最后，和“高-宽-频道”（HWC），即频道第一。维度顺序与数据步长的顺序相同。在HWC格式中，沿通道的数据以步长为1存储，沿宽度的数据以通道数的步长存储，沿高度的数据以（通道数×图像宽度）步长存储。

linuxmint搭建Qt开发环境

Tue, 13 Apr 2021 00:00:00 GMT

最近想学一种桌面应用开发技术，之前大学的时候因为课程原因，学了下javafx，但是个人不喜欢java，后面就没深入去学，现在基本上忘了。后来毕业前准备找工作的时候学了两天Qt，当时只学了一些简单的GUI设计，结果面试没过😭，也没深入去学。再然后玩博客的时候，接触了一些前端的技术，发现有很多桌面应用是基于Electron开发的，这东西感觉挺不错的，跨平台，而且开发出来的界面很好看，不过貌似比较占用资源。

最后还是打算学Qt，Qt有C++和python接口，而且跨平台，能在windows、linux和mac上跑，因为之前学过一点点，所以上手会快一点吧。

安装#

Anaconda里包含Qt的库和相关的工具，所以安装好Anaconda，把Anaconda加到PATH环境变量就能用Qt了。

如果没装Anaconda的话，也可以用apt命令安装Qt：

1
sudo apt-get install qt5-default

hello world#

这里我打算用C++来写Qt，听说用python来写会简单一点，习惯python的小伙伴可以尝试一下，接口很相似的。Qt有个官方的IDE，叫Qt Creator，实际上不用这个IDE也可以很方便地写Qt代码，有qmake和make就够了，先试试编译一个“hello world”程序吧。

首先创建一个文件夹，在里面新建一个main.cpp文件，往里面写代码，代码内容如下：

1
#include <QApplication> /* 应用程序抽象类 */
2
#include <QWidget>  /* 窗口类 */
3

4
int main(int argc, char *argv[])
5
{
6
  QApplication app(argc, argv);
7

8
  QWidget widget; /* 构造一个窗口 */
9
  widget.setWindowTitle("Hello World"); /* 设置窗口标题 */
10
  widget.show(); /* 显示窗口 */
11

12
  return app.exec(); /* exec():进入消息循环 */
13
}

代码的功能是用Qt创建一个标题是“Hello World”的窗口，然后显示出来。

然后再新建一个hello_world.pro文件，作为Qt的项目文件，把刚刚的main.cpp加到项目里去：

1
# 因为用了QWidget，所以要加上这个
2
QT += widgets gui
3

4
# 把main.cpp加到项目的代码列表里
5
SOURCES += \
6
  main.cpp

最后在文件夹下打开终端，用qmake和make编译，编译好后运行生成的hello_world程序。
Terminal window
```
1
$ mkdir build
2
$ cd build/
3
$ qmake ../hello_world.pro
4
$ make
5
$ ./hello_world
```

一切顺利的话，可以看到一个标题是“Hello World”的窗口。

vscodium搭建Qt开发环境#

主要是.vscode目录下的三个json文件，一个是tasks.json，这个是用来配置vscodium编译Qt项目的，其实就是让vscodium运行qmake和make命令，可以参考一下我的配置。

1
{
2
    "tasks": [
3
        {
4
            "type": "shell",
5
            "label": "qt_build_debug",
6
            "command": "rm",
7
            "args": [
8
        "-rf", "./*",
9
                "&&", "qmake", "${file}", "CONFIG+=debug", "CONFIG+=qml_debug",
10
                "&&", "make"
11
            ],
12
            "options": {
13
                "cwd": "${workspaceRoot}/build"
14
            }
15
        }
16
    ],
17
    "version": "2.0.0"
18
}

展开收起

然后是launch.json，用来配置运行或调试编译好的Qt程序。

1
{
2
  "version": "0.2.0",
3
  "configurations": [
4
    {
5
      "name": "qt_launch",
6
      "type": "cppdbg",
7
      "request": "launch",
8
      "program": "${workspaceRoot}/build/${fileBasenameNoExtension}",
9
      "args": [],
10
      "stopAtEntry": false,
11
      "cwd": "${workspaceFolder}",
12
      "environment": [],
13
      "externalConsole": false,
14
      "MIMode": "gdb",
15
      "setupCommands": [
16
        {
17
          "description": "为 gdb 启用整齐打印",
18
          "text": "-enable-pretty-printing",
19
          "ignoreFailures": true
20
        }
21
      ],
22
      "preLaunchTask": "qt_build_debug",
23
      "miDebuggerPath": "/usr/bin/gdb"
24
    }
25
  ]
26
}

展开收起

最后一个是c_cpp_properties.json，这个用来配置vscodium的语法补全，这个要装C++的插件才行。

1
{
2
    "configurations": [
3
        {
4
            "name": "Linux",
5
            "includePath": [
6
                "${workspaceFolder}/**",
7
                "/home/ganyuo/program/anaconda3/include/qt/**" /* 这里需要根据anaconda的安装路径改 */
8
            ],
9
            "defines": [],
10
            "compilerPath": "/usr/bin/g++",
11
            "cStandard": "gnu17",
12
            "cppStandard": "gnu++14",
13
            "intelliSenseMode": "gcc-x64"
14
        }
15
    ],
16
    "version": 4
17
}

展开收起

配置好以后，打开一个Qt的.pro项目文件，按F5编译运行。

图像LBP特征的提取

Thu, 18 Mar 2021 00:00:00 GMT

本文内容大部分抄袭引用自大佬的一篇博客。

背景#

LBP（Local Binary Pattern，局部二值模式）是一种用来描述图像局部纹理特征的算子，具有旋转不变形和灰度值不变形等显著优点。主要用于纹理特征提取，在人脸识别部分有较好的效果。

概述#

从94年T. Ojala, M.Pietikäinen, 和D. Harwood提出至今，LBP大致经历了三个版本。下面按照时间顺序进行介绍。

原始的LBP#

最初的LBP算子通过定义一个3x3的窗口，以窗口内中心点的像素值为标准，对比窗口内另8个点像素值的大小，大于为1，小于为0。8个点形成一个二进制数字（通常转换为十进制表示）即为中心点的LBP特征值。详细计算如下图：

通过上面得到的LBP算子具有很多缺点，之后研究人员在LBP基础上进行不断改进。

1
/**
2
 ************************************
3
 * @author   : ganyuo
4
 * @date     : 2021-03-18
5
 ************************************
6
 * @brief :
7
 *     提取图像的原始LBP特征
8
 */
9

10
#include <stdio.h>
11

12
#include <opencv2/core.hpp>
13
#include <opencv2/highgui.hpp>
14
#include <opencv2/imgproc.hpp>
15

16
void origin_LBP_feature(cv::InputArray src, cv::OutputArray dst);
17

18
int main(int argc, char *argv[])
19
{
20
  cv::Mat src_img, dst;
21

22
  src_img = cv::imread("img/img1.png", cv::IMREAD_GRAYSCALE);
23
  cv::imshow("原图", src_img);
24

25
  origin_LBP_feature(src_img, dst);
26
  cv::imshow("原始LBP特征", dst);
27

28
  cv::waitKey();
29
  return 0;
30
}
31

32
/**
33
 * @brief : 提取图像的原始LBP特征
34
 * @param src : 输入的图像
35
 * @param dst : 图像src的原始LBP特征
36
 * @return : None
37
 */
38
void origin_LBP_feature(cv::InputArray src, cv::OutputArray dst)
39
{
40
  cv::Mat _src, _dst, border_src;
41
  int i, j;
42

43
  /* 填充图像的边界 */
44
  _src = src.getMat();
45
  cv::copyMakeBorder(_src, border_src, 1, 1, 1, 1, cv::BORDER_CONSTANT, cv::Scalar(0));
46
  dst.create(_src.rows, _src.cols, _src.type());
47
  _dst = dst.getMat();
48

49
  /* 循环处理每个像素 */
50
  for(i = 0; i < dst.rows(); i++)
51
  {
52
    for(j = 0; j < src.cols(); j++)
53
    {
54
      uchar center = border_src.at<uchar>(i + 1, j + 1);
55
      uchar lbp_code = 0;
56
      lbp_code |= ((border_src.at<uchar>(i + 0, j + 0) > center) << 7);
57
      lbp_code |= ((border_src.at<uchar>(i + 0, j + 1) > center) << 6);
58
      lbp_code |= ((border_src.at<uchar>(i + 0, j + 2) > center) << 5);
59
      lbp_code |= ((border_src.at<uchar>(i + 1, j + 2) > center) << 4);
60
      lbp_code |= ((border_src.at<uchar>(i + 2, j + 2) > center) << 3);
61
      lbp_code |= ((border_src.at<uchar>(i + 2, j + 1) > center) << 2);
62
      lbp_code |= ((border_src.at<uchar>(i + 2, j + 0) > center) << 1);
63
      lbp_code |= ((border_src.at<uchar>(i + 1, j + 0) > center) << 0);
64
      _dst.at<uchar>(i, j) = lbp_code;
65
    }
66
  }
67
}

展开收起

改进的LBP#

原始LBP算子计算区域为像素点的周围8个点，在图像尺寸发生改变时会出现很大的偏差，不能正确反映像素点周围的纹理信息。为适应不同尺寸纹理特征，LBP原作者将圆形邻域代替正方形邻域。同时增加了旋转不变的特性，在对LBP特征值的存储部分，也进行了改进。详细如下文。

圆形LBP特征#

圆形LBP特征以像素点为圆心，RRR为半径，提取半径上PPP个采样点，根据原始的LBP 中像素值比较方法，进行像素值大小的比较，得到该点的LBP特征值。其中提取采样点的方法如下：

xt=xd+Rcos⁡(2πpP)yt=yd+Rcos⁡(2πpP)\begin{aligned} x_t = x_d + R\cos(\frac{2\pi p}{P}) \\ y_t = y_d + R\cos(\frac{2\pi p}{P}) \end{aligned}xt=xd+Rcos(P2πp)yt=yd+Rcos(P2πp)

(xt,yt)(x_t, y_t)(xt,yt)为某个采样点，(xd,yd)(x_d, y_d)(xd,yd)为邻域中心点，ppp为第p个采样点，PPP为采样点的个数。得到采样点的坐标可能为小数，改进后的LBP采用双线性插值法进行计算该点的像素值，计算公式如下：

f(x,y)≈[1−(x−⌊x⌋)x−⌊x⌋][f(⌊x⌋,⌊y⌋)f(⌊x⌋,⌊y⌋+1)f(⌊x⌋+1,⌊y⌋)f(⌊x⌋+1,⌊y⌋+1)][1−(y−⌊y⌋)y−⌊y⌋]f(x, y) \approx \left[\begin{matrix} 1 - (x - \lfloor x \rfloor) & x - \lfloor x \rfloor \end{matrix} \right] \left[\begin{matrix} f(\lfloor x \rfloor, \lfloor y \rfloor) & f(\lfloor x \rfloor, \lfloor y \rfloor + 1) \\ f(\lfloor x \rfloor + 1, \lfloor y \rfloor) & f(\lfloor x \rfloor + 1, \lfloor y \rfloor + 1) \end{matrix} \right] \left[\begin{matrix} 1 - (y - \lfloor y \rfloor) \\ y - \lfloor y \rfloor \end{matrix} \right]f(x,y)≈[1−(x−⌊x⌋)x−⌊x⌋][f(⌊x⌋,⌊y⌋)f(⌊x⌋+1,⌊y⌋)f(⌊x⌋,⌊y⌋+1)f(⌊x⌋+1,⌊y⌋+1)][1−(y−⌊y⌋)y−⌊y⌋]

几种不同半径不同采样点数量的LBP算子：

1
/**
2
 * @brief : 提取图像的圆形LBP特征
3
 * @param src : 输入的图像
4
 * @param dst : 图像src的圆形LBP特征
5
 * @return : None
6
 */
7
void circular_LBP_feature(cv::InputArray src, cv::OutputArray dst, int num_neighbor, double radius)
8
{
9
  cv::Mat _src, _dst, border_src;
10
  int i, j, k, padding;
11
  double x, y, neighbor;
12

13
  _src = src.getMat();
14
  dst.create(_src.rows, _src.cols, _src.type());
15
  _dst = dst.getMat();
16
  /* 填充图像的边界 */
17
  padding = (int)radius + 1;
18
  cv::copyMakeBorder(_src, border_src,
19
    padding, padding, padding, padding, cv::BORDER_CONSTANT, cv::Scalar(0));
20

21
  /* 循环处理每个像素 */
22
  for(i = 0; i < dst.rows(); i++)
23
  {
24
    for(j = 0; j < src.cols(); j++)
25
    {
26
      uchar center = border_src.at<uchar>(i + padding, j + padding);
27
      uchar lbp_code = 0;
28
      for(k = 0; k < num_neighbor; k++)
29
      {
30
        /* 根据公式计算第k个采样点的坐标，这个地方可以优化，不必每次都进行计算radius*cos，radius*sin */
31
        x = (double)j + radius * cos(2.0 * CV_PI * k / num_neighbor);
32
        y = (double)i + radius * sin(2.0 * CV_PI * k / num_neighbor);
33
        neighbor = bilinear_interpolation(src, x, y);
34
        lbp_code |= ((neighbor > center) << (num_neighbor - k - 1));
35
      }
36
      _dst.at<uchar>(i, j) = lbp_code;
37
    }
38
  }
39
}
40

41
/**
42
 * @brief : 利用双线性内插计算图像的浮点像素值
43
 * @param src : 需要插值的图像
44
 * @param x : x坐标
45
 * @param y : y坐标
46
 * @return : 图像src在浮点坐标(x, y)处的浮点像素值
47
 */
48
double bilinear_interpolation(cv::InputArray src, double x, double y)
49
{
50
  cv::Mat _src = src.getMat();
51
  if(x < 0 || x > _src.cols || y < 0 || y > _src.rows)
52
  {
53
    return 0;
54
  }
55

56
  /* 图像中与浮点像素最近的四个整数坐标值(lx:左x、rx:右x、uy:上y、dy:下y) */
57
  double lx = (int)x;
58
  double rx = lx + 1;
59
  double uy = (int)y;
60
  double dy = uy + 1;
61

62
  /* 先计算y方向的两个像素点值f1、f2，再计算xy两个方向上的像素点值 */
63
  double f1 = (rx - x) * _src.at<uchar>(uy, lx) + (x - lx) * _src.at<uchar>(uy, rx);
64
  double f2 = (rx - x) * _src.at<uchar>(dy, lx) + (x - lx) * _src.at<uchar>(dy, rx);
65
  double xy = (dy - y) * f1 + (y - uy) * f2;
66
  return xy;
67
}

展开收起

旋转不变LBP特征#

上面通过采取圆形邻域的计算，一定程度上削弱了尺度改变的影响。研究人员在上面的基础上进一步扩展，使具备旋转不变的特征。

首先，在确定半径大小和采样点数目后，不断旋转圆形邻域内采样点的位置，得到一系列的LBP特征值，从这些LBP特征值中选择最小的值作为LBP中心像素点的LBP特征值，具体如下图：

通过不断旋转，取最小值，使具备旋转不变特性。

1
/**
2
 * @brief : 对LBP特征图像进行旋转不变处理
3
 * @param src : 输入的LBP特征图像
4
 * @param dst : 进行旋转不变处理后的特征图像
5
 * @return : None
6
 */
7
void rotation_invariant(cv::InputArray src, cv::OutputArray dst, int num_neighbor)
8
{
9
  cv::Mat _src, _dst;
10
  int i, j, k;
11
  uchar current_value, min_value, temp;
12

13
  _src = src.getMat();
14
  dst.create(_src.rows, _src.cols, _src.type());
15
  _dst = dst.getMat();
16

17
  /* 循环处理每个像素 */
18
  for(i = 0; i < _src.rows; i++)
19
  {
20
    for(j = 0; j < _dst.cols; j++)
21
    {
22
      current_value = _src.at<uchar>(i, j);
23
      min_value = current_value;
24
      for(k = 1; k < num_neighbor; k++)
25
      {
26
        /* 循环右移k位 */
27
        temp = (current_value >> k) | (current_value << (num_neighbor - k));
28
        temp &= (0xff >> (8 - num_neighbor));
29
        if(temp < min_value)
30
        {
31
          min_value = temp;
32
        }
33
      }
34
      _dst.at<uchar>(i, j) = min_value;
35
    }
36
  }
37
}

展开收起

统一模式LBP特征#

统一模式LBP（Uniform Pattern LBP）特征也称为等价模式或均匀模式。对LBP特征值的存储方式上，进行了优化。详细如下。

假设对于半径为RRR的圆形邻域内提取PPP个采样点，会产生2P2^P2P种二进制表达方法，随着邻域内采样点数目的增加，二进制模式的种类以指数形式增加，不利于LBP特征值的存储、提取、分类和识别。LBP原作者提出一种“统一模式”对LBP算子进行降维。详细如下。

在实际图像中，绝大多数LBP模式只包括从0到1或从1到0的转变，LBP原作者将“统一模式”定义为当某个LBP特征值所对应的二进制数从0到1或从1到0的转变最多有两次时，该LBP所对应的二进制就称为一个统一模式。如00000000（0次跳变）、00000011（1次跳变）、10001111（2次跳变）均为统一模式类。除统一模式类外均归为混合模式类。上述算法，使得模式数量由原来的2P2^P2P种减少为P(P−1)+2+1P(P - 1) + 2 + 1P(P−1)+2+1种（PPP代表采样点的数量）。

实例介绍：

如采样点数为8，即256种LBP特征值，根据统一模式可分为59类：跳变0次——2个，跳变1次——0个，跳变2次——56个，…跳变8次——1个。（跳变1次为0个是因为LBP作者把LBP二进制数字看做一个圆性的序列，故跳变1次为0个）

1
/**
2
 * @brief : 对LBP特征进行统一模式编码
3
 * @param src : 输入的LBP特征
4
 * @param dst : 用统一模式编码的LBP特征
5
 * @return : None
6
 */
7
void uniform_pattern(cv::InputArray src, cv::OutputArray dst, int num_neighbor)
8
{
9
  cv::Mat _src, _dst;
10
  int i, j, k, hop_time;
11
  uchar kind, curr_bit, next_bit;
12
  uchar table[256] = {0};
13

14
  /* 计算编码映射关系 */
15
  kind = 1; /* 用0来表示混合模式类，所以从1开始计算统一模式类 */
16
  for(i = 0; i < 256; i++)
17
  {
18
    /* 计算跳变次数 */
19
    hop_time = 0;
20
    for(j = 0; j < num_neighbor; j++)
21
    {
22
      /* 计算i的二进制第j位，以及j的下一位--第(j + 1) % num_neighbor位 */
23
      curr_bit = (i >> j) & 0x01;
24
      next_bit = (i >> ((j + 1) % num_neighbor)) & 0x01;
25
      if(curr_bit != next_bit)
26
      {
27
        hop_time++;
28
      }
29
    }
30
    /* 跳变次数小于等于2，说明是统一模式类 */
31
    if(hop_time <= 2)
32
    {
33
      table[i] = kind;
34
      kind++;
35
    }
36
  }
37

38
  _src = src.getMat();
39
  dst.create(_src.rows, _src.cols, _src.type());
40
  _dst = dst.getMat();
41
  /* 对输入的LBP特征进行统一模式编码 */
42
  for(i = 0; i < _src.rows; i++)
43
  {
44
    for(j = 0; j < _src.cols; j++)
45
    {
46
      _dst.at<uchar>(i, j) = table[_dst.at<uchar>(i, j)];
47
    }
48
  }
49
}

展开收起

MB-LBP特征#

MB-LBP特征，全称为Multiscale Block LBP,由中科院的研究人员研究发表，原理与HOG特征提取有相似之处，介绍MB-LBP仅用于了解，下面是原理介绍。

首先将图像分为分为多个块，再将每个小块分成多个区域，每个区域的灰度值为该区域内灰度值的平均值。在一个块内，将中心区域的灰度值大小与周围区域的灰度值大小进行比较形成LBP特征值。如下图：

作者对得到的MB-LBP特征值同样进行均值编码。首先，对得到的特征值采用直方图进行表示，计算每一种特征值的数量，进行排序，将排序在前63为的特征值看作是统一模式类，其他的为混合模式类，共64类。

LBPH#

LBP的最后一步改进为LBPH即LBP特征统计直方图的使用，可用于机器学习特征的提取。这种表示方法由Ahonen等人提出，将LBP特征图像分成m个局部块，提取每个局部块的直方图，并依次连接在一起形成LBP特征的统计直方图。具体过程如下：

计算图像中每一像素点的LBP特征值。
图像进行分成多块。（Opencv中默认将LBP特征图像分为8行8列64块区域。）
计算每块区域的LBP特征值的直方图，并将直方图进行归一化。（横坐标为LBP特征值的表示方式，纵坐标为数量）
将上面计算的每块区域特征图像的直方图按顺序依次排列成一行，形成LBP特征向量。
用机器学习方法对LBP特征向量进行训练。

举例说明LBPH的维度：

采样点为8个，如果用的是原始的LBP或Extended LBP特征，其LBP特征值的模式为256种，则一幅图像的LBP特征向量维度为：64×256=1638464 \times 256 = 1638464×256=16384维，而如果使用统一模式LBP特征，其LBP值的模式为59种，其特征向量维度为：64×59=377664 \times 59 = 377664×59=3776维，可以看出，使用统一模式特征，其特征向量的维度大大减少，这意味着使用机器学习方法进行学习的时间将大大减少，而性能上没有受到很大影响。

1
/**
2
 * @brief : 提取图像的LBP特征统计直方图
3
 * @param src : 输入的图像
4
 * @param dst : 图像的LBP特征统计直方图，大小为(grid_w, grid_h, num_patterns)
5
 * @param num_patterns : LBP模式的种类
6
 * @param grid_w : 分块后的宽度，图像最终分成 grid_w×grid_h 个块
7
 * @param grid_h : 分块后的高度
8
 * @return : None
9
 */
10
void histogram_LBP_feature(cv::InputArray src, cv::OutputArray dst, int num_patterns, int grid_w, int grid_h)
11
{
12
  cv::Mat _src, _dst, block;
13
  int i, j;
14
  int weight, height;
15
  int dst_row_index;
16
  int32_t block_histogram[256];
17
  uchar *data, *dst_row_ptr;
18

19
  _src = src.getMat();
20
  dst.create(cv::Size(grid_w, grid_h), CV_32SC(num_patterns));
21
  _dst = dst.getMat();
22
  weight = (int)(_src.cols / grid_w);
23
  height = (int)(_src.rows / grid_h);
24

25
  dst_row_ptr = _dst.data;
26
  for(i = 0; i < grid_h; i++)
27
  {
28
    for(j = 0; j < grid_w; j++)
29
    {
30
      /* 对图像切块 */
31
      block = cv::Mat(_src, cv::Rect(j * weight, i * height, weight, height));
32
      /* 计算块的直方图 */
33
      memset(block_histogram, 0x00, sizeof(block_histogram));
34
      for(data = block.data; data != block.dataend; data++)
35
      {
36
        block_histogram[*data]++;
37
      }
38
      /* 将块的直方图存到dst的一行里 */
39
      memcpy(dst_row_ptr, block_histogram, 4 * num_patterns);
40
      /* dst_row_ptr指向dst的下一行 */
41
      dst_row_ptr = dst_row_ptr +  4 * num_patterns;
42
    }
43
  }
44
}

展开收起

linuxmint搭建stm32开发环境

Tue, 16 Mar 2021 21:00:00 GMT

先说两句#

最近公司要做一个单片机上的项目，虽然之前学过一点点，不过当时只会写“hello world”级别的代码。感觉这东西挺好玩的，趁着晚上下班没事学一下，随便记录一下开发环境的搭建过程。

开发板是STM32F407G-DISC1，大学搞飞控的时候买的，当时我在团队里面是划水的。之前是在win10系统开发，现在换了linuxmint系统，要重新学一下怎么搭环境，主要是参考大佬的 https://blog.csdn.net/u010000843/article/details/114531922 这篇博客搭的。用到的工具先列一下吧：

工具	介绍
vscodium	vscode完全开源版的IDE，和vscode很像
STM32CubeMX	ST公司的代码自动生成工具
gcc-arm-none-eabi	arm平台的GNU编译器
openOCD	开源的烧录调试工具

好的，接下来就开始吧。

开发工具安装#

vscodium#

去GitHub上下载，地址：https://github.com/vscodium/vscodium/releases。建议不要装1.5x.x版本的，代码提示经常加载不出来，vscode也是一样。

STM32CubeMX#

ST官网上下载安装就好了，传送门。

gcc-arm-none-eabi#

这个在arm官网上有，传送门，下载后解压到你喜欢的某个路径下，然后把里面的bin目录添加到PATH环境变量里。方法如下：

Terminal window

1
$ vi ~/.bashrc
2

3
# 打开.bashrc后把下面这两句添加到里面
4
GCC_ARM_NONE_EABI_HOME="" # 这里写gcc-arm-none-eabi解压后的路径
5
export PATH="${GCC_ARM_NONE_EABI_HOME}/bin:$PATH"
6

7
# 保存退出后让PATH生效
8
$ source ~/.bashrc

一切顺利的话，可以查到编译器的版本号。

Terminal window

1
$ arm-none-eabi-gcc --version
2
arm-none-eabi-gcc (GNU Arm Embedded Toolchain 9-2020-q2-update) 9.3.1 20200408 (release)
3
Copyright (C) 2019 Free Software Foundation, Inc.
4
This is free software; see the source for copying conditions.  There is NO
5
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

openOCD#

用apt安装：

Terminal window

1
$ sudo apt-get install openocd

成功安装完后可以看到openOCD版本号，电脑用USB线连接上开发板后，可以用lsusb命令可以看到相关信息。

Terminal window展开收起

1
$ openocd -v
2
Open On-Chip Debugger 0.10.0
3
Licensed under GNU GPL v2
4
For bug reports, read
5
  http://openocd.org/doc/doxygen/bugs.html
6
$ lsusb
7
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
8
Bus 003 Device 002: ID 2717:5009 Xiaomi Inc. Mi Gaming Mouse
9
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
10
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
11
Bus 001 Device 005: ID 040b:0a67 Weltrend Semiconductor Weltrend USB Mouse
12
Bus 001 Device 004: ID 05e3:0610 Genesys Logic, Inc. 4-port hub
13
Bus 001 Device 003: ID 0b05:1939 ASUSTek Computer, Inc. AURA LED Controller
14
Bus 001 Device 002: ID 8087:0029 Intel Corp.
15
Bus 001 Device 007: ID 0483:374b STMicroelectronics ST-LINK/V2.1  # <== 这个是我的开发板
16
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

展开收起

生成工程代码#

作为演示，这里就生成一个点亮板子LED灯的代码吧。

创建项目#

首先，打开STM32CubeMX，新建一个project。
然后选择对应的芯片型号，我这块板子用的是STM32F407VGT6这块MCU，所以选这个：

配置项目#

打开调试功能：

打开System Core->SYS，Debug模式选择Serial Wire，也就是SWD。
配置GPIO：

去官网上查这块开发板的CAD文档，在最后一页右下角找到了LED的部分，发现绿色的灯连的是PD12引脚，黄色的灯是PD13，红色的是PD14，蓝色的是PD15，这里就试一下蓝色和红色的灯吧，那接下来配置PD14和PD15这两个引脚就好了。

回到STM32CubeMX里，在芯片图右边找到这两个引脚，鼠标单击，两个引脚都配置成GPIO_Output模式。

然后点击左边的System Core->GPIO就可以看到这两个引脚的配置选项了，接下来把这两个引脚配置成输出高电平(High)，使用推挽输出(Pull-up)方式（不记得这个推挽输出是啥意思了），如下图：

到这里项目就配置好了，接下来是生成代码。

生成代码#

进入Project Manager，填写项目名字和保存路径，选择使用Makefile管理项目，然后点右上角的GENERATE CODE生成代码。

如果是第一次生成代码，会弹出一个框，意思大概是要先下载一个F4的包才能生成代码，这个包默认是下载到home目录下的STM32Cube里，因为文件夹开头是不带”.”隐藏的，对于我这个强迫症来说，受不了home目录下有莫名其妙的文件夹。幸好在Help->Updater Setting有个Repository Folder，可以指定包的保存路径（设置前要先点File保存关闭项目才能设置），把路径改成了CubeMX的安装路径，然后把home目录下的STM32Cube删除，舒服了(๑¯∀¯๑)！

编译烧录#

编译#

在项目目录下make就好了。如果编译成功，项目会在目录下创建一个build文件夹，里面有与项目名字相同的.bin文件和.hex文件。

Terminal window

1
$ make

烧录#

把开发板连上电脑，然后开一个终端，用openocd连接开发板，命令如下：

Terminal window

1
$ openocd -f 烧录器配置文件 -f MCU配置文件

烧录器配置文件在/usr/share/openocd/scripts/interface目录下，MCU的配置文件在/usr/share/openocd/scripts/target目录下，根据开发板选择对应的配置文件。我的这块开发板的烧录器是stlink-v2.1，MCU是STM32F407VGT6，所以连接的命令和输出是酱紫的：

Terminal window展开收起

1
$ openocd -f /usr/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/share/openocd/scripts/target/stm32f4x.cfg
2
Open On-Chip Debugger 0.10.0
3
Licensed under GNU GPL v2
4
For bug reports, read
5
  http://openocd.org/doc/doxygen/bugs.html
6
Info : auto-selecting first available session transport "hla_swd". To override use 'transport select <transport>'.
7
Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
8
adapter speed: 2000 kHz
9
adapter_nsrst_delay: 100
10
none separate
11
Info : Unable to match requested speed 2000 kHz, using 1800 kHz
12
Info : Unable to match requested speed 2000 kHz, using 1800 kHz
13
Info : clock speed 1800 kHz
14
Info : STLINK v2 JTAG v25 API v2 SWIM v14 VID 0x0483 PID 0x374B
15
Info : using stlink api v2
16
Info : Target voltage: 2.890749
17
Info : stm32f4x.cpu: hardware has 6 breakpoints, 4 watchpoints

展开收起

连接成功后再开一个终端，用telnet连接本地的4444端口，与openocd通信。然后用program 生成的hex文件路径把程序烧录进开发板，如果出现** Programming Finished **，说明烧录成功。然后用reset命令重启开发板，这个时候应该就可以看到开发板的红灯和蓝灯亮了，最后用exit命令退出。

Terminal window展开收起

1
$ telnet localhost 4444   # 连接
2
Trying 127.0.0.1...
3
Connected to localhost.
4
Escape character is '^]'.
5
Open On-Chip Debugger
6
> program /home/ganyuo/code/stm32f4_led/build/stm32f4_led.hex  # 烧录
7
Unable to match requested speed 2000 kHz, using 1800 kHz
8
Unable to match requested speed 2000 kHz, using 1800 kHz
9
adapter speed: 1800 kHz
10
target halted due to debug-request, current mode: Thread
11
xPSR: 0x01000000 pc: 0x08000f6c msp: 0x20020000
12
Unable to match requested speed 8000 kHz, using 4000 kHz
13
Unable to match requested speed 8000 kHz, using 4000 kHz
14
adapter speed: 4000 kHz
15
** Programming Started **
16
auto erase enabled
17
target halted due to breakpoint, current mode: Thread
18
xPSR: 0x61000000 pc: 0x20000046 msp: 0x20020000
19
wrote 16384 bytes from file /home/ganyuo/code/stm32f4_led/build/stm32f4_led.hex in 0.616047s (25.972 KiB/s)
20
** Programming Finished **  # 表示烧录成功
21
> reset   # 重启开发板
22
Unable to match requested speed 2000 kHz, using 1800 kHz
23
Unable to match requested speed 2000 kHz, using 1800 kHz
24
adapter speed: 1800 kHz
25
> exit  # 退出
26
Connection closed by foreign host.

展开收起

配置vscodium#

安装ARM插件#

在vscodium插件商店里搜索ARM和Cortex-Debug，安装。vscodium默认用的是插件商店是open-vsx.org，下载比较慢，而且很多vscode库里的插件没有，改成vscode库的方法可以参考这里传送门。

添加C++配置#

用vscodium打开项目后会有很多红色的报错，可以添加C/C++的配置文件来去掉。按下快捷键Ctrl+Shift+p，输入C/C++，然后点击Edit Configurrations(JSON)

然后打开项目目录下的.vscode/c_cpp_properties.json文件，把defines配置成下面这样：

1
{
2
    "configurations": [
3
        {
4
            "name": "Linux",
5
            "includePath": [
6
                "${workspaceFolder}/**"
7
            ],
8
            "defines": [
9
                "USE_HAL_DRIVER", /* 加上这两个 */
10
                "STM32F407xx"     /* 这个要根据MCU型号来写 */
11
            ],
12
            "compilerPath": "/home/ganyuo/programs/gcc-arm-none-eabi/bin/arm-none-eabi-gcc",
13
            "cStandard": "gnu17",
14
            "cppStandard": "gnu++14",
15
            "intelliSenseMode": "gcc-arm"
16
        }
17
    ],
18
    "version": 4
19
}

展开收起

一键编译烧录调试#

在工程的.vscode目录下新建一个tasks.json和launch.json。

tasks.json用来编译项目，在这里就是make一下，可以参考下面这样写。

1
{
2
    "tasks": [
3
        {
4
            "type": "shell",
5
            "label": "task_build",
6
            "command": "make",
7
            "args": [],
8
            "options": {
9
                "cwd": "${workspaceFolder}"
10
            }
11
        }
12
    ],
13
    "version": "2.0.0"
14
}

launch.json用来配置运行和调试，可以参考下面这样写。

1
{
2
    "version": "0.2.0",
3
    "configurations": [
4
        {
5
            "name": "Cortex Debug",
6
            "cwd": "${workspaceRoot}",
7
            "preLaunchTask": "task_build",
8
            "executable": "${workspaceRoot}/build/${workspaceFolderBasename}.elf",
9
            "request": "launch",
10
      "type": "cortex-debug",
11
      "svdFile": "STM32F407.svd",
12
            "servertype": "openocd",
13
            "configFiles":[
14
                "/usr/share/openocd/scripts/interface/stlink-v2-1.cfg",
15
                "/usr/share/openocd/scripts/target/stm32f4x.cfg"
16
            ],
17
            "armToolchainPath": "/home/ganyuo/programs/gcc-arm-none-eabi/bin"
18
        }
19
    ]
20
}

展开收起

launch.json里面有个svdFile配置项，用来指定svd文件，有这个文件能查看寄存器的值，不配置这个选项也能调试。可以在https://github.com/posborne/cmsis-svd找到，每个MCU都不同，下载对应的svd文件，放到项目目录下就好了。

接下来试一下能不能调试，在Core/Src/main.c的main函数里设置一个断点，然后按F5开始调试，然后就gg了…emmmm…

打开调试控制台，发现报了下面这个错误。

undefined/home/ganyuo/programs/gcc-arm-none-eabi/bin/arm-none-eabi-gdb: error while loading shared libraries: libncurses.so.5: cannot open shared object file: No such file or directory

意思是说找不到libncurses.so.5这个动态链接库，用ldconfig命令找了一下，发现只有libncurses.so.6，2333…

Terminal window

1
$ ldconfig -p | grep libncurses.so
2
  libncurses.so.6 (libc6,x86-64) => /lib/x86_64-linux-gnu/libncurses.so.6

用apt-get把libncurses5这个包装上以后就可以找到这个库了。

1
$ sudo apt-get install libncurses5
2
$ ldconfig -p | grep libncurses.so
3
  libncurses.so.6 (libc6,x86-64) => /lib/x86_64-linux-gnu/libncurses.so.6
4
  libncurses.so.5 (libc6,x86-64) => /lib/x86_64-linux-gnu/libncurses.so.5

再试一下能不能调试，这次没问题了，开心！<(*￣▽￣*)/

刚开始调试的时候会停在用来引导的汇编代码里面，继续按F5就运行到main函数里的断点了。

装的第一台电脑

Tue, 24 Nov 2020 00:00:00 GMT

先说两句#

前阵子因为大学用的小米笔记本屏幕坏了，所以买了个2K的显示器，外接给笔记本用。虽然日常用起来不卡，不过笔记本摸起来很烫，风扇经常呼啦呼啦地转，可能是盖起盖子影响了散热，也可能是以笔记本的性能带个2K显示器有点吃力，毕竟是个轻薄本吗。总之，我是迫不得已才剁手买电脑的，绝对不是因为笔记本打游戏太卡了的原因。

配置说明#

电脑配件	型号	价格
cpu	AMD 3600x	￥1366
显卡	还没买到	￥105
主板	华硕重炮手B550M(带wifi)	￥739
内存	金士顿骇客神条3600，8G×2	￥689
电源	酷冷至尊sfx 650w	￥878
硬盘	三星970 EVO Plus 500G + 西部数据SN550 1T	￥649 + ￥749
机箱	酷鱼s5	￥300
散热器	乔思伯CR-1400	￥79
风扇	利民TL-C12S×2 + 乔思伯FR925×3	￥179.8 +￥89.7
		￥5823.5

趁着双11降价，除了显卡外（显卡涨地飞起，想再等等），其他电脑配件都买到了。第一次配电脑，瞎买的，感觉没配好，然后因为配的是itx电脑，所以性价比比较低。

CPU#

CPU选的是AMD的3600X，因为双11降价，只花了￥1366，这个CPU感觉算性价比比较高，3700X和5600X感觉稍微有点贵了。

显卡#

这个不想说，因为比特币涨价的问题，显卡都被矿老板收走了，缺货特别严重。现在显卡已经涨得特别离谱，所以就花￥100块钱买了张二手GT450亮机卡凑合着用。

主板#

主板选的是华硕的B550M，没选B450M是因为微星和华硕的B450M都没wifi和蓝牙，而且不支持PCIE4（听说华硕的刷新BIOS后支持了），选华硕是因为华硕的灯光同步做的比较好。

主板拆开以后是这样的：

内存#

内存条选的是两根8G的金士顿的骇客神条3600，买金士顿是因为听说兼容性好，后期如果升级成4根的话可能会方便一点。

电源#

因为酷鱼s5只支持sfx电源，所以选了酷冷至尊的sfx 650w，海韵的太贵了，酷冷的这个相对便宜一点。一开始买的是550w，后来感觉不太够，找售后退了，换了650w的，这电源3070显卡应该也勉强扛得住。

我买的是全模组的，送了一堆的线：

硬盘#

一开始是打算买西部数据的SN750 500G作为系统盘的，后来发现三星970 EVO Plus 500G读写速度会快一点，而且也只贵了一点点，所以选了三星的。然后买一张西部数据SN550 1T作为数据盘。

机箱#

机箱看上了两款——先马趣造、酷鱼s5，这两款都是能装matx主板的小机箱，先马趣造稍微大一点，但是能装atx电源，因为只有黑色款的，感觉比较难看，最终还是选了酷鱼s5。后来我买了没多久，先马趣造就出了白色款了…，早知道就再等等了。机箱拆开是这样的：

这款机箱的特点是能装matx主板，不过做工一般，感觉不值这个价，而且不能走背线，装机难度相对先马趣造难一些。不说了，越说越后悔当时没再等等。

散热器#

买的是乔思伯CR-1400，买这个散热器是因为机箱限高135mm，符合这个高度还带RGB的就这款了，4热管压3600X是没问题的。

风扇#

机箱的顶部可以装两个9cm的风扇，尾部可以装一个9cm的风扇，底部可以装两个12cm的风扇进风。itx机箱散热稍微差一点，多装一些风扇会好一点，所以我选择都装上，其实最主要是因为风扇有RGB。买了两个利民的TL-C12S，3个乔思伯的FR925，因为主板上只有两个风扇的接口，所以买了两根风扇的一分三扩展线。

配置大概就是这样的，接下来开始装机。

装机#

安装电源#

根据这款机箱的设计，要先装电源再装主板，没错，我就是顺序搞错了才知道的，。先把机箱的玻璃侧板拆了，然后把尾部的风扇、顶部风扇支架、电源支架还有电源线都拆了，再给机箱顶部贴上防尘网（后面如果装了主板就不方便贴了）。然后用螺丝把电源固定在电源支架上，再把电源支架装回机箱里。固定电源的那个螺丝特别难对准，说到这我又后悔没买先马趣造了。

安装CPU#

把主板的CPU卡扣打开。CPU的四个角里，有一个角是标记过的，用来和主板对准，主板的CPU底座也有一个角是标记过的，把CPU和主板的这两个特殊的角对应好（在下面图里，这两个角是左上角），再把CPU放到底座上面就好了，然后把卡扣扣上。

安装散热器#

先把主板CPU附近的散热器卡扣螺丝拧下来，拆掉散热器卡扣，然后给装好的CPU涂上硅脂，一点点就好了，不用涂太均匀，等会散热器放上去会压均匀的，我第一次涂，涂的有点丑。

把散热器拿出来，撕掉底部的膜，这个很重要，一定不要忘了撕膜。然后给散热器装上AMD的支架，一般散热器会配Intel和AMD的支架，注意不要装错了支架，不然装不到主板上。装好散热器支架后把散热器固定到主板上，拧螺丝的时候要注意，不要一个螺丝一次拧到底，要四个角的螺丝轮着来拧，每次拧一点，还有就是不要把螺丝拧太死，感觉能压住CPU也不会晃就可以了。

安装内存条#

matx的主板一般有4个内存条卡槽，如果是装两个内存条的话，装在第2和第4槽会好一点。先把主板的内存条卡扣打开，然后把内存条按进去，内存条上有防呆口，方向反了的话是按不进去的，按的时候卡扣会自动扣上，等完全扣上说明内存条装好了。

安装主板#

安装主板比较头疼的就是接线了，因为主板上的接口比较多，不百度不看说明书的话，根本不知道怎么接。

先把主板的CPU供电线和主板供电线接上。华硕的这款主板CPU供电线在左上角，CPU供电线不同的主板可能会不同，一般是两个4pin并在一起的。主板供电线在内存条右边，主板的供电限比较好认，最大的那个24pin的就是了。

然后把主板的IO挡板装到机箱的尾部，把主板放进机箱。一般机箱和主板之间都会有一些空隙，防止主板和机箱金属接触，造成短路，这部分空隙可以用来走线，也就是走背线，可以把CPU的供电线从主板上面引到主板背面，然后再从背面引到电源的接口附近，这样可以减少主板上面空间的占用，而且也更好看一点。主板的供电线因为太多了，我的这个机箱不方便走背线。放好主板后把主板的固定螺丝拧紧就好了。

最后把机箱的电源开关线、USB外接线接到主板上，不同的主板接口位置可能会不同，具体要看说明书。最后装好是这样的：

安装硬盘#

把主板上硬盘的固定螺丝拆下来，然后把硬盘装上去，再把螺丝拧回去就好了，这个比较简单。

安装风扇#

因为我的风扇是带灯的，所以每个风扇有两个线要连，一个是给风扇供电的，一个是控制风扇的RGB灯的。华硕的这款主板只有两个风扇的供电接口，我这里加上散热器上的风扇，一共有6个风扇，两根一分三的扩展线刚刚好能给所有风扇供电。装好以后感觉线太乱了，所以把线用扎带绑了一下，稍微理得好看了一点，最后是这样的：

安装显卡#

把主板上的显卡卡槽打开，然后把显卡对准，摁进去，然后用螺丝把显卡和机箱尾部的PCIE挡板固定，把其他不用的PCIE挡板用防尘板挡住，防止进灰。华硕的这款主板，显卡是插在第2个的PCIE卡槽上的，然后因为底部风扇把第4个PCIE卡槽的空间给占用了，所以如果要插太厚的显卡要把底部的风扇给拆下来才行，微星的B550M显卡是插第一个PCIE卡槽上的，不会有这个问题。

新买的捷安特ATX830自行车

Tue, 15 Sep 2020 21:00:00 GMT

先说两句#

很久以前就想买一辆自行车了，奈何没钱家境贫寒，一直没买，前段时间坐公交上班的时候，经常因为堵车迟到，所以就决定去买一辆来代步。本来想买辆便宜点的喜德盛，后来被某有钱人建议怂恿，就选了捷安特。

昨天去专卖店里买的，买这种品牌自行车还是去正规专卖店好，以后可以免费保养，售后会好一点。我对自行车不太懂，因为是用来上下班，店长就向我推荐了两款，ATX810和ATX830。考虑到ATX810飞轮是8速的（店长说9速的稳定性比8速的好很多），而且这两款价格相差不太大，所以最终选这款ATX830，价格￥2489，它的详细配置如下。

部件	型号
车架	GIANT ATX8 ALUXX铝合金车架
前叉	铝合金线控锁死避震前叉
车把	GIANT 31.8铝合金直把
车首竖杆	铝合金竖杆
座垫杆	铝合金座垫杆
座垫	GIANT运动座垫
变速把手	标配小副把
前变速器	27S
后变速器	27S
刹车	油压碟刹
大齿盘	锻造铝腿22/30/40T大齿盘
轮胎	GIANT QUICKCROSS 27.5x1.95 30TPI山地轮胎
轮组	GAINT 双层铝合金轮圈 + GIANT 铝合金培林花鼓

店里有3种颜色选择，橙色、黑色和灰色，个人不喜欢灰色，橙色也不是很喜欢的颜色，如果有粉色就好了，最终选了黑色，整体的样子就是下面这张图片的样子。

车架#

型号是GIANT ATX8 ALUXX铝合金车架，这个是ALUXX是捷安特的铝合金车架成型技术，网上说是入门级的，更高端的还有ALUXX SL和ALUXX SLR，貌似比ALUXX更轻一点。整体感觉不重，但也不算轻，铝合金的车架要比碳纤维的稍微重一点，车架是内走线的，刹车线从车架里面传到变速器和后刹车。

前叉#

这个前叉应该是前面减震的这个东西，这款是可以用线控器锁住减震的，店长说上坡的时候锁住会好骑一点。

车把和车首竖杆#

都是铝合金的，车把有副把，如果路况比较好，不怎么刹车的话，可以用副把来骑，减轻手腕的酸痛。车把上左右各一个变速器和刹车器，还有锁住前叉的线控器和铃铛。

刹车#

油压碟刹的，比机械碟刹的好一点，具体不太懂，店长说刹车的碟片来令片不能碰到油，会影响刹车的制动力。

大齿盘#

锻造铝腿22/30/40T大齿盘。

飞轮#

9速的，不太懂，店长说骑的时候多变速可以减轻链条对飞轮片的磨损，增加自行车的使用寿命。

轮组#

轮组是自行车里比较重要的部分，我这款用的是GAINT 双层铝合金轮圈 + GIANT 铝合金培林花鼓，不太懂，对于我这种用来上下班的来说，应该算还不错吧。

轮胎#

轮胎用的是27.5x1.95的，店长建议车胎内压力在40~60psi之间会好一点。

座垫和座垫杆#

座垫坐起来感觉还不错，座垫杆这里经过特殊处理，可以增加座垫杆和车架的摩擦，防止坐垫滑动。店长帮我在坐垫下面装了个尾灯，晚上骑行会安全一点。

车锁#

这个车锁是比较有意思的，见下图，店长说这个锁防液压剪，价格￥338感觉有点小贵。

总结#

我个人感觉这辆车整体来说还不错，从店里到家一个骑了7公里多的路，没感觉到累，骑起来挺轻松的，自行车和各种配件一共￥3282。可惜天气预报显示这周会一直下雨，没法骑这这辆自行车去上班了，还是要坐公交，去淘宝上买个浴衣雨衣吧。

UVA-796 Critical Links

Mon, 31 Aug 2020 18:00:00 GMT

题目#

https://onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=737

题意#

给出一张无向图，求图的割边。

题目解析#

大致的思路和求图的割点类似，用tarjan算法解决。

代码#

1
#include <stdio.h>
2
#include <string.h>
3
#include <algorithm>
4
#define min(a, b) (a < b) ? a : b
5

6
const int MAX_N = 1000 + 10;
7

8
typedef struct node
9
{
10
  int b;
11
  int next;
12
} node;
13

14
typedef struct edge
15
{
16
  int a, b;
17
} edge;
18

19
int cmp(edge a, edge b)
20
{
21
  if(a.a != b.a)
22
  {
23
    return a.a < b.a;
24
  }
25
  else
26
  {
27
    return a.b < b.b;
28
  }
29
}
30

31
int n, bn;
32
node e[2 * MAX_N * MAX_N];
33
edge bridge[MAX_N];
34
int head[MAX_N];
35
int vis[MAX_N], v_ind;
36
int low[MAX_N];
37

38
void tarjan(int v, int pre)
39
{
40
  int i, b;
41

42
  vis[v] = v_ind;
43
  low[v] = v_ind;
44
  v_ind++;
45
  for(i = head[v]; i != -1; i = e[i].next)
46
  {
47
    b = e[i].b;
48
    if(vis[b] == 0)
49
    {
50
      tarjan(b, v);
51
      low[v] = min(low[v], low[b]);
52
      if(low[b] > vis[v])
53
      {
54
        if(v < b)
55
        {
56
          bridge[bn].a = v;
57
          bridge[bn].b = b;
58
        }
59
        else
60
        {
61
          bridge[bn].a = b;
62
          bridge[bn].b = v;
63
        }
64
        bn++;
65
      }
66
    }
67
    else if(b != pre)
68
    {
69
      low[v] = min(low[v], vis[b]);
70
    }
71
  }
72
}
73

74
int main()
75
{
76
  int a, k, b;
77
  int i, j, en;
78

79
  while(scanf("%d", &n) != EOF)
80
  {
81
    memset(head, -1, sizeof(head));
82
    en = 0;
83
    for(i = 0; i < n; i++)
84
    {
85
      scanf("%d (%d)", &a, &k);
86
      for(j = 0; j < k; j++)
87
      {
88
        scanf("%d", &b);
89
        e[en].b = b;
90
        e[en].next = head[a];
91
        head[a] = en;
92
        en++;
93
      }
94
    }
95
    bn = 0;
96
    v_ind = 1;
97
    memset(vis, 0, sizeof(vis));
98
    for(i = 0; i < n; i++)
99
    {
100
      if(vis[i] == 0)
101
      {
102
        tarjan(i, i);
103
      }
104
    }
105

106
    std::sort(bridge, bridge + bn, cmp);
107
    printf("%d critical links\n", bn);
108
    for(i = 0; i < bn; i++)
109
    {
110
      printf("%d - %d\n", bridge[i].a, bridge[i].b);
111
    }
112
    printf("\n");
113
  }
114
  return 0;
115
}

展开收起

UVA-315 Network

Thu, 06 Aug 2020 14:34:00 GMT

题目#

https://onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=251

题意#

给出一张无向图，求图中割点的个数。割点是指删除该点后，其他点之间的连通性会受到影响的点。

题目解析#

用tarjan算法来解决，这题的输入有点麻烦，因为输入的问题runtime error了好几次。

代码#

1
/* https://cn.vjudge.net/contest/67418#problem/B */
2
#include <stdio.h>
3
#include <string.h>
4
#define min(a, b) (a < b) ? a : b
5

6
const int MAX_N = 100 + 10;
7

8
int n;
9
int mp[MAX_N][MAX_N];
10
int vis[MAX_N], vis_n;
11
int low[MAX_N];
12
int is_ctp[MAX_N];
13

14
void tarjan(int v, int root)
15
{
16
  int i, child = 0;
17

18
  vis[v] = vis_n;
19
  low[v] = vis_n;
20
  vis_n++;
21
  for(i = 1; i <= n; i++)
22
  {
23
    if(mp[v][i] != 0)
24
    {
25
      if(vis[i] == -1)
26
      {
27
        tarjan(i, root);
28
        low[v] = min(low[v], low[i]);
29
        if(v == root)
30
        {
31
          child++;
32
        }
33
        else if(low[i] >= vis[v])
34
        {
35
          is_ctp[v] = 1;
36
        }
37
      }
38
      else
39
      {
40
        low[v] = min(low[v], vis[i]);
41
      }
42
    }
43
  }
44
  if(v == root && child >= 2)
45
  {
46
    is_ctp[root] = true;
47
  }
48
}
49

50
int main()
51
{
52
  int i, a, b, ans;
53
  char ch;
54

55
  while(scanf("%d", &n) != EOF && n != 0)
56
  {
57
    memset(mp, 0, sizeof(mp));
58
    while(scanf("%d", &a) != EOF && a != 0)
59
    {
60
      while(getchar() != '\n')
61
      {
62
        scanf("%d", &b);
63
        mp[a][b] = 1;
64
        mp[b][a] = 1;
65
      }
66
    }
67

68
    memset(vis, -1, sizeof(vis));
69
    memset(is_ctp, 0, sizeof(is_ctp));
70
    for(i = 1; i <= n; i++)
71
    {
72
      if(vis[i] == -1)
73
      {
74
        vis_n = 1;
75
        tarjan(i, i);
76
      }
77
    }
78
    ans = 0;
79
    for(i = 1; i <= n; i++)
80
    {
81
      if(is_ctp[i] == 1)
82
      {
83
        ans++;
84
      }
85
    }
86
    printf("%d\n", ans);
87
  }
88
  return 0;
89
}

展开收起

图像的灰度变换

Thu, 16 Jul 2020 14:32:00 GMT

介绍#

灰度变换是所有图像处理技术中最简单的技术，输出图像在点(x,y)(x, y)(x,y)处的像素值仅取决于原图在点(x,y)(x, y)(x,y)处的像素值。可以用公式s=T(r)s = T(r)s=T(r)表示，rrr和sss分别表示处理前后的像素值，TTT是把像素值rrr映射到像素值sss的一种变换。

因为处理的是数字量，所以变换函数的值通常存储在一个一维阵列里，从rrr到sss的映射是通过查表实现的。对于8位的灰度图，TTT包含256个灰度值的映射。

图像增强常用的三类变换函数是：线性变换、对数变换、幂律变换。

反转变换#

这个比较简单，对于一张灰度级范围为[0, L - 1]的图像，sss就等于L−1−rL - 1 - rL−1−r，用公式表示是：s=L−rs = L - rs=L−r。

使用这种变换方式可以反转一幅图像的灰度值，得到类似照片底片的效果。

对数变换#

对数变换的通用公式为：

s=clog⁡(1+r)s = c\log(1 + r)s=clog(1+r)

式中ccc是常数，并假设r>=0r>=0r>=0。对数变换和反对数变换的曲线如下所示，蓝色曲线代表对数变换，橙色曲线代表反对数变换（图上反对数变换的公式有点看不清，是s=erc−1s=e^{\frac{r}{c}} - 1s=ecr−1），c的取值为L−1T(L−1)\frac{L - 1}{T(L - 1)}T(L−1)L−1。对数变换将输入中范围较窄的低灰度值映射为输出中范围较宽的灰度值，将输入中范围较宽的高灰度值映射为输出中范围较窄的灰度值。使用这种类型的变换来扩展图像中的暗像素值，同时压缩更高灰度级的值。反对数变换的作用则相反。

幂律变换#

幂律变换也叫伽马变换，它的通用公式为：

s=crγs = cr^{\gamma}s=crγ

式中ccc和γ\gammaγ是常数。不同γ\gammaγ值的幂律变换曲线如下所示。

分段线性变换函数#

分段线性变换函数和名字描述的一样，就是按照不同的范围段，用线性函数进行变换。其优点是形式可以任意复杂，缺点是函数要人为调整。

对比度拉伸#

对比度拉伸是最简单的分段线性变换之一，对比度拉伸是扩展图像灰度级动态范围的处理，因此可以跨越记录介质和显示装置的全部灰度范围。下图是一个对比度拉伸的典型函数图像。

通过变换后，灰度值在[r1,r2][r_1, r_2][r1,r2]范围内的像素会线性拉伸到[s1,s2][s_1, s_2][s1,s2]范围内，最终的结果是在范围[r1,r2][r_1, r_2][r1,r2]内会增强对比度，其他范围内的对比度会降低。

灰度级分层#

用于突出图像中特定范围的亮度，可以用来增强某些特征。给个书上的例图吧，不想码字了！

比特平面分层#

对于8比特的灰度图，每个像素由8个比特位构成，如果把图像上所有像素的特定位置的比特位单独拿出来，就可以构成一张只包含0和1的二值图像，该图像就叫原图像的比特平面。比如取每个像素中8个比特位的第7个比特位，构成该图像的第7比特平面。

一幅图像中高位的比特平面包含了视觉上很重要的大多数数据，低位的比特平面则展现了图像更精细的灰度细节。

POJ_1236 Network of Schools

Wed, 08 Jul 2020 11:40:00 GMT

题目#

http://poj.org/problem?id=1236

题意#

有N个学校用一些单向的网络连接一起，每个学校得到一套软件后，可以通过单向网络向周边的学校传输。

问题1：初始至少需要向多少个学校发放软件，使得网络内所有的学校最终都能得到软件。

问题2：至少需要添加几条传输线路，使任意向一个学校发放软件后，经过若干次传送，网络内所有的学校最终都能得到软件。

题目解析#

将学校当做点，网络线路当做边，得到一个有向图，算出这个图里所有的强连通分量。因为同一个强连通分量之间的任意两点可以互相连通，所以向一个点发送软件后，与这个点同属于一个强连通分量的点都能收到软件。可以将每个强连通分量都假设为一个点，然后算出所有强连通分量的入度和出度，假设入度为0的强连通分量的个数为d_in0，出度为0的强连通分量的个数为d_out0。问题1的答案等于d_in0；当强连通分量的个数为1时，问题2的答案等于0，当强连通分量的个数大于1时，问题2的答案等于max(d_in0, d_out0)。

代码#

1
/* AC 0MS 356K */
2
#include <stdio.h>
3
#include <string.h>
4

5
const int MAX_N = 100 + 10;
6

7
int n;
8
int mp[MAX_N][MAX_N];
9
int vis[MAX_N], vis_t;
10
int st[MAX_N], st_top;
11
int in_st[MAX_N];
12
int low[MAX_N];
13
int belong[MAX_N], ccn;
14

15
int tarjan(int v)
16
{
17
  int i, k;
18

19
  vis[v] = vis_t;
20
  low[v] = vis_t;
21
  vis_t++;
22
  st_top++;
23
  st[st_top] = v;
24
  in_st[v] = 1;
25
  for(i = 0; i < n; i++)
26
  {
27
    if(mp[v][i] == 0)
28
    {
29
      continue;
30
    }
31
    if(vis[i] == 0)
32
    {
33
      tarjan(i);
34
      if(low[v] > low[i])
35
      {
36
        low[v] = low[i];
37
      }
38
    }
39
    else if(in_st[i] == 1 && low[v] > vis[i])
40
    {
41
      low[v] = vis[i];
42
    }
43
  }
44
  if(low[v] == vis[v])
45
  {
46
    k = -1;
47
    while(k != v)
48
    {
49
      k = st[st_top];
50
      st_top--;
51
      in_st[k] = 0;
52
      belong[k] = ccn;
53
    }
54
    ccn++;
55
  }
56
}
57

58
int main()
59
{
60
  int i, j, k;
61
  int d_in0, d_out0;
62
  int d_in[MAX_N], d_out[MAX_N];
63

64
  scanf("%d", &n);
65
  memset(mp, 0, sizeof(mp));
66
  for(i = 0; i < n; i++)
67
  {
68
    while(scanf("%d", &k) != EOF && k !=0)
69
    {
70
      mp[i][k - 1] = 1;
71
    }
72
  }
73

74
  /* 计算强连通分量 */
75
  memset(vis, 0, sizeof(vis));
76
  memset(in_st, 0, sizeof(in_st));
77
  ccn = 0;
78
  for(i = 0; i < n; i++)
79
  {
80
    if(vis[i] == 0)
81
    {
82
      st_top = -1;
83
      vis_t = 1;
84
      tarjan(i);
85
    }
86
  }
87

88
  /* 计算每个强连通分量的入度和出度 */
89
  memset(d_in, 0, sizeof(d_in));
90
  memset(d_out, 0, sizeof(d_out));
91
  for(i = 0; i < n; i++)
92
  {
93
    for(j = 0; j < n; j++)
94
    {
95
      if(mp[i][j] == 1 && belong[i] != belong[j])
96
      {
97
        d_in[belong[j]]++;
98
        d_out[belong[i]]++;
99
      }
100
    }
101
  }
102

103
  d_in0 = 0;
104
  d_out0 = 0;
105
  for(i = 0; i < ccn; i++)
106
  {
107
    if(d_in[i] == 0)
108
    {
109
      d_in0++;
110
    }
111
    if(d_out[i] == 0)
112
    {
113
      d_out0++;
114
    }
115
  }
116
  if(ccn == 1)
117
  {
118
    printf("1\n0\n");
119
  }
120
  else
121
  {
122
    printf("%d\n%d\n", d_in0, (d_in0 > d_out0) ? d_in0 : d_out0);
123
  }
124

125
  return 0;
126
}

展开收起

图像的几何空间变换

Fri, 03 Jul 2020 09:54:55 GMT

介绍#

图像的几何空间变换可以改进图像中像素间的空间关系，主要由两个基本操作组成：

坐标空间的变换。
图像内插，对空间变换后的像素赋值。

空间坐标变换#

可由下式表示：

(x,y)=T{(v,w)}(x, y) = T\{(v, w)\}(x,y)=T{(v,w)}

上式中(v,w)(v, w)(v,w)是原图中像素的坐标，(x,y)(x, y)(x,y)是变换后图像的坐标，TTT是变换函数，也就是原图中某个位置的像素通过变换函数，映射到目标图像中。比如：(x,y)=T(v,w)=(v/2,w/2)(x, y) = T{(v, w)} = (v/2, w/2)(x,y)=T(v,w)=(v/2,w/2)表示在两个方向上将原图缩小一半。

图像内插#

请参考我的另一篇博文图像内插。

仿射变换#

仿射变换是最常用的空间坐标变换之一，其一般形式如下：

[xy1]=[vw1]T=[vw1][t11t120t21t220t31t321]\left[\begin{matrix} x & y & 1 \end{matrix}\right] = \left[\begin{matrix} v & w & 1 \end{matrix}\right]T = \left[\begin{matrix} v & w & 1 \end{matrix}\right] \left[\begin{matrix} t_{11} & t_{12} & 0 \\ t_{21} & t_{22} & 0 \\ t_{31} & t_{32} & 1 \end{matrix}\right][xy1]=[vw1]T=[vw1]t11t21t31t12t22t32001

上式中，TTT表示变换矩阵，可根据TTT中元素所选择的值，对一组坐标点做尺度、旋转、平移或偏移。

变换名称	变换矩阵TTT	坐标公式
恒等变换	[100010001]\left[\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{matrix}\right]100010001	x=vy=wx = v \\ y = wx=vy=w
尺度变换	[cx000cy0001]\left[\begin{matrix} c_x & 0 & 0 \\ 0 & c_y & 0 \\ 0 & 0 & 1\end{matrix}\right]cx000cy0001	x=cxvy=cywx = c_x v \\ y = c_y wx=cxvy=cyw
平移变换	[100010txty1]\left[\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ t_x & t_y & 1\end{matrix}\right]10tx01ty001	x=v+txy=w+tyx = v + t_x \\ y = w + t_yx=v+txy=w+ty
旋转变换	[cos⁡θsin⁡θ0−sin⁡θcos⁡θ0001]\left[\begin{matrix} \cos\theta & \sin\theta & 0 \\ -\sin\theta & \cos\theta & 0 \\ 0 & 0 & 1\end{matrix}\right]cosθ−sinθ0sinθcosθ0001	x=vcos⁡θ−wsin⁡θy=vsin⁡θ+wcos⁡θx = v\cos\theta - w\sin\theta \\ y = v\sin\theta + w\cos\thetax=vcosθ−wsinθy=vsinθ+wcosθ
垂直偏移变换	[1sh0010001]\left[\begin{matrix} 1 & s_h & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{matrix}\right]100sh10001	x=vy=w+shvx = v \\ y = w + s_hvx=vy=w+shv
水平偏移变换	[100sv10001]\left[\begin{matrix} 1 & 0 & 0 \\ s_v & 1 & 0 \\ 0 & 0 & 1\end{matrix}\right]1sv0010001	x=v+svwy=wx = v + s_vw \\ y = wx=v+svwy=w

实现#

实现空间变换的方法有两种：

前向映射：整体思想是扫描原图像，对于原图像上的每个像素，根据它在原图中的坐标(v,w)(v, w)(v,w)，利用(x,y)=T{(v,w)}(x, y) = T\{(v, w)\}(x,y)=T{(v,w)}计算其在目标图像上的坐标(x,y)(x, y)(x,y)，然后将原图中坐标为(v,w)(v, w)(v,w)的像素值赋值给目标图像中坐标为(x,y)(x, y)(x,y)的像素。
反向映射：整体思想是扫描目标图像的每个像素，对于坐标为(x,y)(x, y)(x,y)的像素，利用(v,w)=T−1{(x,y)}(v, w) = T^{-1}\{(x, y)\}(v,w)=T−1{(x,y)}计算其在原图像上的坐标(v,w)(v, w)(v,w)，然后用内插的方法计算该像素的值。

这里T−1T^{-1}T−1表示变换函数的反函数，对于仿射变换来说，相当于[xy1]\left[\begin{matrix} x & y & 1 \end{matrix}\right][xy1]乘变换矩阵的逆矩阵。

使用前向映射可能会存在两个问题，一个是原图像中多个像素被变换到目标图像的同一个位置，产生冲突，另一个问题是计算出的目标像素坐标不存在，比如不是个整数坐标。而反向映射不存在这两个问题，因此反向映射用的多一点。

这里给出用反向映射实现仿射变换的C++代码，代码用的是opencv库处理图像。

1
#include <opencv2/core.hpp>
2
#include <opencv2/highgui.hpp>
3
#include <opencv2/imgproc.hpp>
4

5
using namespace cv;
6

7
/* 原图路径 */
8
char img_path[100] = "img/affine.png";
9
/* 变换后图像的大小 */
10
Size img_out_size = {300, 300};
11
/* 仿射矩阵 */
12
double T[3][3] =
13
{
14
  {1, 0, 0},
15
  {0, 1, 0},
16
  {0, 0, 1},
17
};
18

19
/* 利用双线性内插计算原图中的浮点像素值 */
20
double bilinear_interpolation(Mat src, double x, double y)
21
{
22
  if(x < 0 || x > src.cols || y < 0 || y > src.rows)
23
  {
24
    return 0;
25
  }
26

27
  /* 表示在原图中与浮点像素最近的四个整数坐标值(lx:左x、rx:右x、uy:上y、dy:下y) */
28
  double lx = (int)x;
29
  double rx = lx + 1;
30
  double uy = (int)y;
31
  double dy = uy + 1;
32

33
  /* 先计算y方向的两个像素点值f1、f2，再计算xy两个方向上的像素点值 */
34
  double f1 = (rx - x) * src.at<uchar>(uy, lx) + (x - lx) * src.at<uchar>(uy, rx);
35
  double f2 = (rx - x) * src.at<uchar>(dy, lx) + (x - lx) * src.at<uchar>(dy, rx);
36
  double xy = (dy - y) * f1 + (y - uy) * f2;
37
  return xy;
38
}
39

40
int main()
41
{
42
  int i, j;
43
  Mat src = imread(img_path, cv::IMREAD_GRAYSCALE);
44
  src.rows -= 2;
45
  Mat dst = Mat(img_out_size, src.type());
46

47
  Mat t_s = Mat(3, 3, CV_64FC1, T);
48
  Mat t_inv = Mat(3, 3, CV_64FC1);
49
  invert(t_s, t_inv); // t_inv为仿射矩阵的逆矩阵
50

51
  Mat src_vec, dst_vec;
52
  for(i = 0; i < dst.rows; i++)
53
  {
54
    for(j = 0; j < dst.cols; j++)
55
    {
56
      /* 目标图像的坐标向量 */
57
      dst_vec = (Mat_<double>(1, 3) << j, i, 1);
58
      /* 计算dst_vec对应于原图中的坐标向量src_vec */
59
      src_vec = dst_vec * t_inv;
60
      /* 计算目标图像的浮点像素值 */
61
      dst.at<uchar>(i, j) = (uchar)bilinear_interpolation(src, src_vec.at<double_t>(0, 0), src_vec.at<double_t>(0, 1));
62
    }
63
  }
64
  imshow("dst", dst);
65
  imwrite("img/t_1.png", dst);
66

67
  waitKey(0);
68
  return 0;
69
}

展开收起

HDU_4081 Qin Shi Huangs National Road System

Fri, 19 Jun 2020 19:00:07 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=4081

题目描述#

During the Warring States Period of ancient China(476 BC to 221 BC), there were seven kingdoms in China ---- they were Qi, Chu, Yan, Han, Zhao, Wei and Qin. Ying Zheng was the king of the kingdom Qin. Through 9 years of wars, he finally conquered all six other kingdoms and became the first emperor of a unified China in 221 BC. That was Qin dynasty ---- the first imperial dynasty of China(not to be confused with the Qing Dynasty, the last dynasty of China). So Ying Zheng named himself “Qin Shi Huang” because “Shi Huang” means “the first emperor” in Chinese.

Qin Shi Huang undertook gigantic projects, including the first version of the Great Wall of China, the now famous city-sized mausoleum guarded by a life-sized Terracotta Army, and a massive national road system. There is a story about the road system:

There were n cities in China and Qin Shi Huang wanted them all be connected by n-1 roads, in order that he could go to every city from the capital city Xianyang.

Although Qin Shi Huang was a tyrant, he wanted the total length of all roads to be minimum,so that the road system may not cost too many people’s life. A daoshi (some kind of monk) named Xu Fu told Qin Shi Huang that he could build a road by magic and that magic road would cost no money and no labor. But Xu Fu could only build ONE magic road for Qin Shi Huang. So Qin Shi Huang had to decide where to build the magic road. Qin Shi Huang wanted the total length of all none magic roads to be as small as possible, but Xu Fu wanted the magic road to benefit as many people as possible ---- So Qin Shi Huang decided that the value of A/B (the ratio of A to B) must be the maximum, which A is the total population of the two cites connected by the magic road, and B is the total length of none magic roads.

Would you help Qin Shi Huang?

A city can be considered as a point, and a road can be considered as a line segment connecting two points.

输入#

The first line contains an integer t meaning that there are t test cases(t <= 10).

For each test case:

The first line is an integer n meaning that there are n cities(2 < n <= 1000).

Then n lines follow. Each line contains three integers X, Y and P ( 0 <= X, Y <= 1000, 0 < P < 100000). (X, Y) is the coordinate of a city and P is the population of that city.

It is guaranteed that each city has a distinct location.

输出#

For each test case, print a line indicating the above mentioned maximum ratio A/B. The result should be rounded to 2 digits after decimal point.

样例输入#

样例输出#

题意#

有n个城市，给出每个城市的坐标和人口数，秦始皇想修一些路，使得这n个城市之间可以互相连通，同时希望花费最少的劳动力（修的路的长度总和越大，花费的劳动力越多）。有一个叫徐福的道士可以用魔法帮秦始皇修一条路，并且不需要额外的劳动力，不过徐福希望他用魔法修的路能帮到更多的人。所以他们最终决定采集A/B最小的方案，A是通过魔道连接的两个城市的总人口，而B是不用魔法修的路的总长度。求A/B的最小值。

题目解析#

次小生成树的变形。先求出最小生成树的总长度mst_l和maxd数组，然后枚举图上的每一条边，作为用魔法修的路，那么不用魔法修的路的总长度为mst_l-maxd[i][j]，再根据两个城市的总人口，就可以算出A/B的最小值。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=4081 */
2
/* AC 109MS 16968K */
3
#include <stdio.h>
4
#include <string.h>
5
#include <math.h>
6

7
const int MAX_N = 1000 + 10;
8

9
typedef struct node
10
{
11
  int x, y, p;
12
} node;
13

14
int n;
15
node nd[MAX_N];
16
int mst[MAX_N];
17
double mp[MAX_N][MAX_N];
18
double maxd[MAX_N][MAX_N];
19

20
double prim()
21
{
22
  int i, j, k;
23
  double min, mst_l;
24
  double dist[MAX_N];
25

26
  for(i = 0; i < n; i++)
27
  {
28
    dist[i] = mp[0][i];
29
    mst[i] = 0;
30
  }
31
  dist[0] = -1;
32
  memset(maxd, 0, sizeof(maxd));
33

34
  mst_l = 0;
35
  for(i = 1; i < n; i++)
36
  {
37
    min = 1e10;
38
    for(j = 1; j < n; j++)
39
    {
40
      if(dist[j] != -1 && min > dist[j])
41
      {
42
        min = dist[j];
43
        k = j;
44
      }
45
    }
46
    if(min == 1e10)
47
    {
48
      return -1;
49
    }
50
    mst_l += min;
51
    dist[k] = -1;
52
    for(j = 0; j < n; j++)
53
    {
54
      if(dist[j] == -1 && j != k)
55
      {
56
        int pre = mst[k];
57
        maxd[j][k] = (maxd[j][pre] > mp[pre][k]) ? maxd[j][pre] : mp[pre][k];
58
        maxd[k][j] = maxd[j][k];
59
      }
60
      if(dist[j] != -1 && dist[j] > mp[k][j])
61
      {
62
        dist[j] = mp[k][j];
63
        mst[j] = k;
64
      }
65
    }
66
  }
67
  return mst_l;
68
}
69

70
double solve()
71
{
72
  int i, j;
73
  double mst_l, mst_sl, temp, ans;
74

75
  mst_l = prim();
76
  ans = 0;
77
  for(i = 0; i < n; i++)
78
  {
79
    for(j = 0; j < n; j++)
80
    {
81
      if(i == j)
82
      {
83
        continue;
84
      }
85
      temp = mst_l - maxd[i][j];
86
      if(ans < (nd[i].p + nd[j].p) / temp)
87
      {
88
        ans = (nd[i].p + nd[j].p) / temp;
89
      }
90
    }
91
  }
92
  return ans;
93
}
94

95
int main()
96
{
97
  int t, i, j;
98
  double ans;
99

100
  scanf("%d", &t);
101
  while(t--)
102
  {
103
    scanf("%d", &n);
104
    for(i = 0; i < n; i++)
105
    {
106
      scanf("%d %d %d", &nd[i].x, &nd[i].y, &nd[i].p);
107
    }
108
    for(i = 0; i < n; i++)
109
    {
110
      for(j = 0; j < n; j++)
111
      {
112
        mp[i][j] = pow(nd[i].x - nd[j].x, 2) + pow(nd[i].y - nd[j].y, 2);
113
        mp[i][j] = sqrt(mp[i][j]);
114
        mp[j][i] = mp[i][j];
115
      }
116
    }
117
    ans = solve();
118
    printf("%.2f\n", ans);
119
  }
120
  return 0;
121
}

展开收起

POJ_1679 The Unique MST

Sat, 13 Jun 2020 10:25:00 GMT

题目#

http://poj.org/problem?id=1679

题意#

给出一张无向图，问图的最小生成数是否唯一，不唯一的话输出Not Unique!，否则输出最小生成树的边权和。

题目解析#

算出图的最小生成树，然后算出次小生成数，判断一下是否相等。（第一次写次小生成树，bug改了好久(T﹏T)！）

代码#

1
/* http://poj.org/problem?id=1679 */
2
/* AC 0MS 412K */
3
#include <stdio.h>
4
#include <string.h>
5

6
const int MAX_N = 100 + 5;
7
const int INF = 0x1f1f1f1f;
8

9
int n, m;
10
int mp[MAX_N][MAX_N];
11
int mst[MAX_N];
12
int maxd[MAX_N][MAX_N];
13

14
int prim()
15
{
16
  int i, j, k, min, ans;
17
  int dist[MAX_N];
18

19
  for(i = 1; i <= n; i++)
20
  {
21
    dist[i] = mp[1][i];
22
    mst[i] = 1;
23
  }
24
  dist[1] = -1;
25

26
  ans = 0;
27
  for(i = 2; i <= n; i++)
28
  {
29
    min = INF;
30
    for(j = 2; j <= n; j++)
31
    {
32
      if(dist[j] != -1 && min > dist[j])
33
      {
34
        min = dist[j];
35
        k = j;
36
      }
37
    }
38
    if(min == INF)
39
    {
40
      return -1;
41
    }
42
    ans += dist[k];
43
    dist[k] = -1;
44
    for(j = 1; j <= n; j++)
45
    {
46
      if(dist[j] != -1 && dist[j] > mp[k][j])
47
      {
48
        dist[j] = mp[k][j];
49
        mst[j] = k;
50
      }
51
      if(dist[j] == -1)
52
      {
53
        int pre = mst[k];
54
        maxd[j][k] = (maxd[j][pre] > mp[pre][k]) ? maxd[j][pre] : mp[pre][k];
55
        maxd[k][j] = maxd[j][k];
56
      }
57
    }
58
  }
59
  return ans;
60
}
61

62
int sec_mst(int mst_l)
63
{
64
  int i, j, ans;
65

66
  ans = INF;
67
  for(i = 1; i <= n; i++)
68
  {
69
    for(j = 1; j <= n; j++)
70
    {
71
      if(i == j || mp[i][j] == INF || mst[i] == j || mst[j] == i)
72
      {
73
        continue;
74
      }
75
      if(ans > mst_l + mp[i][j] - maxd[i][j])
76
      {
77
        ans = mst_l + mp[i][j] - maxd[i][j];
78
      }
79
    }
80
  }
81
  if(ans == INF)
82
  {
83
    return -1;
84
  }
85
  else
86
  {
87
    return ans;
88
  }
89
}
90

91
int main()
92
{
93
  int t, i, x, y, w, mst_l;
94

95
  scanf("%d", &t);
96
  while(t--)
97
  {
98
    scanf("%d %d", &n, &m);
99
    memset(mp, 0x1f, sizeof(mp));
100
    memset(maxd, 0, sizeof(maxd));
101
    for(i = 0; i <= n; i++)
102
    {
103
      mp[i][i] = 0;
104
    }
105
    for(i = 0; i < m; i++)
106
    {
107
      scanf("%d %d %d", &x, &y, &w);
108
      if(mp[x][y] > w)
109
      {
110
        mp[x][y] = w;
111
        mp[y][x] = w;
112
      }
113
    }
114

115
    mst_l = prim();
116
    if(mst_l < 0 || mst_l == sec_mst(mst_l))
117
    {
118
      printf("Not Unique!\n");
119
    }
120
    else
121
    {
122
      printf("%d\n", mst_l);
123
    }
124
  }
125
  return 0;
126
}

展开收起

shell脚本基础知识

Sun, 10 May 2020 22:30:26 GMT

简介#

shell#

shell是操作系统内核之外的指令解析器，是一个程序，同时是一种命令语言和程序设计语言。是处于操作人员和操作系统接口之间的一层封装，用于方便操作人员使用计算机。

用途：

用于计算机的启动、常用程序的运行等脚本。
作为配置文件。
处理文本文件。

常用的shell：sh、bash。

shell脚本#

将多行命令封装进一个文本文件里，执行一个shell脚本即可执行多个shell命令。

shell的第一行用于指定脚本解释器的路径，方法是#!解释器的路径，比如指定为/bin/sh的代码如下：

1
#!/bin/sh

执行方式#

shell有两种执行方式，第一种是脚本解释器 shell文件，第二种是./shell文件。使用第二种方式时，要确保shell文件有可执行权限。

Terminal window

1
bash ./test.sh  # 第一种方式
2
./test.sh  # 第二种方式

注释#

单行注释#

shell脚本里用#来表示单行注释，如果使用第一种方式执行shell，第一行的#!也是注释；如果用第二种方式执行shell，第一行的#!则不是注释。

1
#!/bin/sh
2

3
# 这是一个注释
4
ls -l # 这也是一个注释

多行注释#

方法一
Terminal window
```
1
: '
2
echo "这是一个注释"
3
echo "这也是注释"
4
echo "这还是注释"
5
'
```
注意：注释的开头的:和'之间有一个空格，不然会报错。

方法二

Terminal window

1
:<< 字符
2
echo "这是一个注释"
3
echo "这也是注释"
4
echo "这还是注释"
5
字符

这里的字符上下两个要相同，否则注释无法结束。

别名#

给命令取其他名字，用来简化带参数的命令，比如使用alias ll='ls -l'命令来给ls -l取一个ll的别名，以后就可以用ll来代替ls -l了。

如果是在终端输入alias命令后取的别名，在终端退出后别名就会失效，下次开启终端后，需要再执行一次alias命令才能使用别名。如果想要在每次开启终端后都能使用别名，需要把alias命令写入~/.bashrc文件里。

输入输出#

输出#

echo命令用于将字符输出到标准输出，语法：echo [可选项] 要输出的字符串...，可选项有两个：

-n ：输出后不换行，默认会换一行。
-e ：输出前解析转义字符（类似\n之类的），默认不解析。

Terminal window

1
$ echo 'abc!'   # 输出后会换一行
2
abc!
3
$ echo -n 'abc!'   # 输出后不换行
4
abc!$
5

6
$ echo 'abc\nabc'  # 不解析转义字符，将\n当做普通字符串输出
7
abc\nabc
8
$ echo -e 'abc\nabc'  # 解析转义字符，将\n当做换行符输出
9
abc
10
abc
11
$

cat命令用于将文件的内容输出到标准输出，语法：cat 要输出的文件。

输入#

read命令会从标准输入中读取字符串，保存到变量中，语法：read 保存输入的变量。

Terminal window

1
$ read VAR
2
abc   # 输入的字符串
3
$ echo ${VAR}
4
abc
5
$

也可以用read命令将读取的字符串保存到多个变量中，语法：read 变量1 变量2 ...。read命令读取到空格就换一个变量来保存字符串，读取到回车停止读取。

Terminal window

1
$ read VAR1 VAR2
2
abc 123  # 输入的字符串
3
$ echo ${VAR1}
4
abc
5
$ echo ${VAR2}
6
123
7
$

用read将输入保存到变量时，如果想将空格当做普通字符保存到变量中，可以在空格前加一个反斜杠来转义。

Terminal window

1
$ read VAR1 VAR2
2
abc\ 123 xyz
3
$ echo ${VAR1}
4
abc 123
5
$ echo ${VAR2}
6
xyz
7
$

当用来保存输入的变量是最后一个变量的时候，即使不加反斜杠来转义，也会把空格当做普通字符来处理。

Terminal window

1
$ read VAR1 VAR2
2
abc 123 xyz
3
$ echo ${VAR1}
4
abc
5
$ echo ${VAR2}
6
123 xyz  # 变量VAR2是最后一个保存输入的变量
7
$   # 所以“123”和“xyz”之间的空格，即使不加反斜杠，也当做普通字符处理

如果后面的变量还没有用到，read就读取到了换行，那么，没用到的变量会赋值为空字符串。

Terminal window

1
$ VAR1=xyz
2
$ VAR2=123
3
$ read VAR1 VAR2
4
abc
5
$ echo ${VAR1}
6
abc
7
$ echo ${VAR2} # 变量VAR2原来是123，现在是空字符串。
8

9
$

文件重定向#

一个进程启动时，默认会打开3个文件描述符。

0 标准输入　STDIN_FILENO
1 标准输出　STDOUT_FILENO
2 标准错误　STDERR_FILENO

一般在终端运行的命令会将当前终端作为标准输入、标准输出和标准错误，如果想用一个文件去替换终端，作为该命令的标准输入、标准输出或者标准错误，则需要用到输入输出重定向。输入输出重定向的语法如下：

commad 0<file ：将file文件作为commad命令的标准输入，0可以省略。
commad 1>file ：将commad命令的标准输出重定向到file文件，会覆盖file文件原来的内容，用>>替换>就不会覆盖，会将标准输出追加到file文件里。1也可以省略，效果是一样的。
commad 2>file ：将commad命令的标准错误重定向到file文件，覆盖写入，用>>表示追加，这里2不可以省略。
commad 1>file 2>&1 ：将commad命令的标准输出和标准错误都重定向到file文件，会覆盖file文件原来的内容，用>>表示追加，前面的1可以省略。

Terminal window

1
./a.out <in.txt    # 将in.txt文件作为./a.out的输入
2
./a.out >out.txt   # 将./a.out的标准输出重定向到out.txt文件中，覆盖写入
3
./a.out >>out.txt   # 将./a.out的标准输出重定向到out.txt文件中，追加写入
4
./a.out 2>out.txt   # 将./a.out的标准错误重定向到out.txt文件中，覆盖写入

管道#

用|表示，即将前一条命令的执行结果，利用管道传给下一条命令，作为下一条命令的输入，比如查看test.cpp文件里所有包含printf的行可以使用以下命令：

Terminal window

1
cat test.cpp | grep 'printf'

变量#

变量是一段内存名字。shell里只有字符串和整数两种类型的变量。shell变量常用大写英文字符表示。

声明#

shell变量可以用declare来声明。设定属性的选项：

-a 声明下标数组 (如果支持)
-A 声明关联数组 (如果支持)
-i 声明整型变量
-r 声明只读变量
-n 声明指向一个以其值为名称的变量的引用
-x 声明一个变量，并将变量导出，有关导出的内容会在下文的环境变量里解释。
-t 声明带有`trace’(追踪)属性的变量
-l 将变量在赋值时转为小写
-u 将变量在赋值时转为大写

如果在声明变量时，不指定任何属性，则默认为声明一个字符串类型的变量。

Terminal window

1
#声明一个下标数组
2
declare -a MY_ARRAY
3

4
#声明一个整型变量
5
declare -i MY_INT
6

7
#声明一个只读变量，并将其初始化为'123'
8
declare -r MY_READ_ONLY='123'
9

10
#声明一个变量，并将变量导出
11
declare -x MY_EXPORT
12

13
#声明一个字符串变量
14
declare MY_STRING

其实，字符串类型的变量不用declare声明也可以赋值或者使用，相当于一个空字符串。

Terminal window

1
$ echo "MY_VAR=${MY_VAR};" #在没有用`declare`声明时，使用'MY_VAR'变量
2
MY_VAR=;
3
$ MY_VAR=123 #在没有用`declare`声明时，给'MY_VAR'变量赋值
4
$ echo "MY_VAR=${MY_VAR};"
5
MY_VAR=123;

使用#

语法：$变量名或${变量名}

Terminal window

1
echo $VAR
2
echo ${VAR}

推荐使用加大括号的方式，可以增强代码的可读性。

赋值#

语法：变量名=给变量赋的值

赋值和初始化时等号两边不要加空格。

只读变量初始化后不能再赋值了。

释放#

语法：unset 变量名

Terminal window

1
$ VAR=123
2
$ echo "VAR=${VAR};"
3
VAR=123;
4
$ unset VAR
5
$ echo "VAR=${VAR};"
6
VAR=;

变量VAR在释放之前的值是123，在释放之后是一个空字符串。

局部变量#

局部变量(local variable)是用户自定义的变量，declace不加-x声明的变量都是局部变量。局部变量只在当前shell进程中有效，其父shell进程和其创建的子shell进程都无法使用。

环境变量#

环境变量(global variable)也叫全局变量。与局部变量不同，当前shell进程在创建子shell进程时，会将环境变量复制给子shell进程，使其成为子进程的环境变量，而当前shell进程的局部变量不会复制。

可以用export将局部变量导出为环境变量，语法：export 要导出的局部变量名。

下面，用两个例子来说明环境变量和局部变量的区别。假设当前目录下有一个test.sh脚本，里面只有一条echo命令，如下：

Terminal window

1
echo "VAR=${VAR};"

第一个例子

首先在终端中声明一个名称为VAR的局部变量，然后用bash执行test.sh脚本，结果如下：

Terminal window

1
$ declare VAR='123'
2
$ bash ./test.sh
3
VAR=;

在这个例子中，当前终端可以当做一个shell进程，执行bash ./test.sh命令会创建一个子shell进程，然后用创建的子shell进程去解析test.sh里的命令。因为VAR是一个局部变量，所以在创建子shell进程时，不会将VAR变量复制给子shell进程，所以子shell进程执行test.sh后输出的VAR是一个空字符串。

第二个例子

首先在终端中声明一个名称为VAR的局部变量，先将VAR用export导出为环境变量，然后再用bash执行test.sh脚本，结果如下：

Terminal window

1
$ declare VAR='123'
2
$ export VAR
3
$ bash ./test.sh
4
VAR=123;

与第一个例子不同的地方是VAR被导出成了环境变量，当前终端在创建子shell进程的时候会将VAR复制，成为子shell进程的环境变量，所以输出的VAR是字符串’123’。

可以用env、export、set命令来查看当前shell进程的环境变量。

常用的环境变量：

HOME：home目录路径
PWD：当前目录路径
LOGNAME：当前用户用户名
PATH：shell命令的存放路径，每个路径用引号分隔，用于shell寻找命令。

特殊变量#

$0：用于保存的是当前运行的可执行文件的名字。
$1~9：用于保存给shell脚本或者shell脚本里的函数传的参数，一共有9个。
**#**：用于保存传的参数个数，`0`不在计数范围内。
**\***：以单个字符串的形式保存传的参数，即\1~9，不包括$0。
**\@∗∗：以字符串数组的形式保存传的参数，不包括‘\@**：以字符串数组的形式保存传的参数，不包括`\@∗∗：以字符串数组的形式保存传的参数，不包括‘0`。
$?：用于保存上一条命令或者函数的返回值，值为0表示正常退出。
$$：当前shell进程的PID。
$!：用于保存上一个放到后台运行的进程的PID，注意，不是前台进程。
$-：显示shell使用的当前选项，与set命令功能相同。(这个没弄懂)

后台切换#

在命令后面加一个&可以将该命令切换到后台工作，这样不用等待该命令结束就可以执行下一条命令了。

1
./a.out &
2
ls -l

上面这个例子，假设./a.out需要执行10秒，如果不加&，则ls -l需要等10秒后，也就是./a.out执行结束后才能运行，加了&就不需要等待./a.out结束就能运行ls -l了。

使用这种切换到后台的进程，在终端退出后就会结束，如果想在退出终端后，后台进程任然继续运行，需要用到nohup命令。

1
nohup ./a.out &

使用nohup命令会将切换到后台的进程的输出写入到当前目录的nohup.out文件里。

特殊字符#

双引号#

双引号用来使shell将空格、制表符和其他大多数特殊字符当做普通字符来处理。举个栗子：

Terminal window

1
touch aaa bbb
2
touch "aaa bbb"

没加双引号时，aaa和bbb之间的空格表示命令参数分隔符，touch命令会创建两个文件“aaa”和“bbb”。

加了双引号时，aaa和bbb之间的空格表示普通字符，与a和b的意义相同，touch命令只会创建一个文件“aaa bbb”。

单引号#

作用与双引号类似，区别是双引号只能将空格、制表符等部分特殊符号当普通字符来处理，而单引号可以作用于所有字符。比如$符号(用于引用变量)加了双引号还是特殊字符，加单引号则表示普通字符。

Terminal window

1
echo ${PATH}
2
echo "${PATH}"
3
echo '${PATH}'

上面的三行命令，第一行和第二行的作用相同，都是输出PATH变量，第三行命令只会输出字符串“$PATH”。

反引号#

反引号用于使shell将字符串当做命令来处理。举个例子：

Terminal window

1
echo ls -l
2
echo `ls -l`

第一行命令会将字符串“ls -l”输出，第二行命令则会先执行ls -l命令，然后用echo命令将ls -l的执行结果输出。

反引号也可以用$()来代替，比如`ls -l`和$(ls -l)是等效的。

反斜杠#

转义字符，将反斜杠后面的字符当做普通字符来处理。

Terminal window

1
touch aaa\ bbb

上面命令里的空格被转义为普通字符，执行命令后会创建一个“aaa bbb”文件。

分号#

可以在一行执行多条命令，分号表示一条命令的结束。

Terminal window

1
echo "hello world"; ls -la;

空格、制表符、换行符#

当做空白。

其他符号#

*?!^：用于shell的模式匹配。
<>：用于输入输出重定向，见文件重定向。
|：用于使用管道，见管道。
$：用于引用变量，见变量。
&：将命令放到后台运行，见后台切换。
#：在shell脚本里表示单行注释，见单行注释。
()：$()用来表示括号里的是命令，和反引号作用相同。$(())用来表示表达式运算。
[]：用于shell的模式匹配，或者用来表示表达式运算，也可以用来表示条件判断。
{}：用于shell的模式匹配，或者用来引用变量，也可以用来生成序列，用法见for语句。

模式和正则表达式#

shell里的模式一般用来匹配文件路径，正则表达式则是用来匹配字符串的。

模式#

shell的模式包括普通字符和通配符，这里列出常用的一些通配符：

通配符	含义	实例
`*`	匹配0个或多个字符	`a*b`，a与b之间可以有任意长度的任意字符, 也可以一个也没有，比如：aabcb, axyzb, a012b, ab。
`?`	匹配任意一个字符	`a?b`，a与b之间必须也只能有一个字符, 可以是任意字符，比如：aab, abb, acb, a0b。
`[list]`	匹配list中的任意单一字符	`a[xyz]b`，a与b之间必须也只能有一个字符, 但只能是x或y或z, 比如：axb, ayb, azb。
`[c1-c2]`	匹配c1到c2之间的任意一个字符	`a[0-9]b`，a与b之间必须也只能有一个0到9之间的字符，比如：a0b, a1b… a9b。
`[!list]`或`[^list]`	匹配除list中的任意单一字符	`a[!xyz]b`，a与b之间必须也只能有一个字符, 但不能是x、y、z, 比如：a0b, apb, a-b。
`[!c1-c2]`或`[^c1-c2]`	匹配不在c1-c2的任意字符	`a[!0-9]b`，比如：acb adb。
`{string1,string2,...}`	匹配sring1或string2(或更多)其一字符串	`a{abc,xyz,123}b`，a与b之间必须是abc或xyz或123，比如：aabcb,axyzb,a123b

shell里的模式一般用来匹配多个文件或文件夹的路径，使用模式的常用命令有：ls、find、cp、mv、chmod…。

Terminal window

1
$ ls -1 test_[0-9].sh
2
test_0.sh
3
test_1.sh
4
test_2.sh

正则表达式#

正则表达式是用来匹配字符串的。linux里的grep是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来，这里用grep来演示正则表达式。

正则表达式常用元字符集：

字符	含义
`\`	转义字符
`^`	匹配字符串的开始位置
`$`	匹配字符串的结束位置
`.`	匹配任意一个字符
`[list]`	匹配list里的任意一个字符。例如，`[abc]`可以匹配 “plain” 中的 ‘a’。
`[^list]`	匹配除了list里的其他任意一个字符。例如，`[^abc]`可以匹配”plain”中的’p’、‘l’、‘i’、‘n’。
`[c1-c2]`	匹配c1到c2之间的任意字符。例如，`[a-z]`可以匹配’a’到’z’范围内的任意小写字母字符。
`[^c1-c2]`	匹配不在c1到c2之间的任意字符。例如，`[^a-z]`可以匹配任何不在’a’ 到’z’范围内的任意字符。
`x\|y`	匹配x或y。例如，`z\|food`能匹配”z”或”food”，`(z\|f)ood`则匹配”zood”或”food”。
`()`	标记一个子表达式的开始和结束位置。
`*`	匹配前面的子表达式零次或多次。例如，`zo`能匹配”z”以及”zoo”。``等价于`{0,}`。
`+`	匹配前面的子表达式一次或多次。例如，`zo+`能匹配”zo”以及”zoo”，但不能匹配 “z”。`+`等价于`{1,}`。
`?`	匹配前面的子表达式零次或一次。例如，`do(es)?`可以匹配”do”或”does”。`?`等价于`{0,1}`。
`{n}`	匹配前面的子表达式确定的n次。例如，`o{2}`不能匹配”Bob”中的’o’，但是能匹配”food”中的两个’o’。
`{n,}`	至少匹配前面的子表达式n次。例如，`o{2,}`不能匹配 “Bob” 中的 ‘o’，但能匹配”foooood”中的所有’o’。
`{n,m}`	最少匹配前面的子表达式n次且最多匹配m次。例如，`o{1,3}`将匹配”fooooood”中的前三个’o’。注意，在逗号和两个数之间不能有空格。
`\b`	匹配一个单词边界，也就是指单词和空格(shell里的grep并不限于空格，单词和’.’、’_‘之间也能匹配)间的位置。例如，`er\b`可以匹配”never” 中的”er”，但不能匹配 “verb” 中的”er”。
`\B`	匹配非单词边界。`er\B`能匹配”verb”中的”er”，但不能匹配”never”中的”er”。
`\d`	匹配一个数字字符。等价于`[0-9]`。
`\D`	匹配一个非数字字符。等价于 [^0-9]。
`\w`	匹配字母、数字、下划线。等价于`[A-Za-z0-9_]`。
`\W`	匹配非字母、数字、下划线。等价于`[^A-Za-z0-9_]`。
`\xn`	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，`\x41`匹配”A”。`\x041`则等价于’\x04’&“1”。正则表达式中可以使用ASCII编码。
`\s`	匹配任何空白字符，包括空格、制表符、换页符等等。等价于`[\f\n\r\t\v]`。
`\S`	匹配任何非空白字符。等价于`[^\f\n\r\t\v]`。

注意：shell里用grep时，|、()、{}、+、?需要转义。比如：

Terminal window

1
$ ls -1 | grep 'test_1\{2\}'
2
test_11.sh

上面的{和}前面要加\转义。

表达式运算#

运算符#

shell里的运算符基本跟c语言的一样

基本运算符：+、-、*、/(加减乘除)、%(取模)
逻辑运算符：&&、||、!(与或非)
位运算符：&(与)、|(或)、^(异或)、~(取反)、<<(位左移)、>>(位右移)
赋值运算符：=、+=、*=、/=、%=、&=、|=、^|、<<=、…

格式#

shell里用$[表达式]表示中括号里的是表达式，也可以用$((表达式))来表示，推荐使用中括号的形式。

注意：shell里只能对整形变量进行表达式运算，不能对字符串类型的变量进行表达式运算

Terminal window

1
$ declare -i VAR1=123
2
$ declare -i VAR2=111
3
$ echo $[VAR1 + VAR2]
4
234

expr命令#

也可以用expr命令来进行表达式运算，expr命令支持的运算符有：|、&、<、<=、=、!=、>=、+、-、*、/、%。语法：expr 表达式，举个栗子：

Terminal window

1
$ expr 123 + 111  # 加法运算
2
234
3
$ VAR1=333
4
$ VAR2=234
5
$ expr ${VAR1} - ${VAR2}  # 变量１减变量２
6
99
7
$ expr ${VAR1} \* ${VAR2}  # 变量１乘变量２
8
77922
9
$ expr ${VAR1} / ${VAR2}  # 变量１除变量２
10
1

注意：运算符两边都有一个空格。部分运算符前面要加个\来转义，比如*、&、(、>。

还可以用小括号来组成更复杂的表达式。

Terminal window

1
$ expr 12 \* \( 34 - 26 \)  # 乘号和小括号前都要加\
2
96
3
$ declare -i VAR1=413
4
$ declare -i VAR2=34
5
$ expr ${VAR1} % \( ${VAR2} - 21 \)
6
10

expr还可以进行简单的字符串运算，支持的有：

字符串 : 正则表达式：在字符串中由给定正则表达式决定的锚定模式匹配。
match 字符串正则表达式：与“字符串 : 正则表达式”相同。
substr 字符串位置长度：从某个位置开始，截取指定长度的子串，位置由 1 开始计数。
index 字符串字符：字符串中第一次出现指定字符的位置，如果不存在该字符，则输出0。
length 字符串：字符串的长度。

Terminal window

1
$ expr substr 'this is a test' 2 8
2
his is a
3
$ expr length 'this is a test'
4
14
5
$ expr index 'this is a test' s
6
4

expr命令会将计算结果输出到标准输出，如果想将结果保存到变量里，可以用反引号来实现。

Terminal window

1
$ VAR=`expr 23 \* 42`
2
$ echo ${VAR}
3
966

条件判断#

shell里可以用test命令进行条件判断。语法：test 表达式或者[ 表达式 ](注意这里中括号和表达式之间的空格不能省)。

可以通过查看变量$?的值，来判断表达式是否成立，如果成立，test命令返回值为0，变量$?的值也是0，如果不成立，则值为非0。test命令可以进行的条件判断包括以下几种。

字符串判断#

-z 字符串：字符串的长度为 0
-n 字符串：字符串长度非零
字符串：等价于-n 字符串
字符串1 = 字符串2：字符串相等
字符串1 != 字符串2：字符串不相等

Terminal window

1
$ VAR=''
2
$ [ -z ${VAR} ] # 判断字符串${VAR}长度是否为0
3
$ echo $?  # 查看test命令的返回值
4
0
5
$ VAR='abc'
6
$ [ -z ${VAR} ]
7
$ echo $?
8
1
9
$ [ ${VAR} = 'abc' ] # 判断字符串${VAR}是否等于'abc'
10
$ echo $?
11
0
12
$ [ ${VAR} = '123' ]
13
$ echo $?
14
1

整数判断#

整数1 -eq 整数2：整数1与整数2相等
整数1 -ge 整数2：整数1大于或等于整数2
整数1 -gt 整数2：整数1大于整数2
整数1 -le 整数2：整数1小于或等于整数2
整数1 -lt 整数2：整数1小于整数2
整数1 -ne 整数2：整数1和整数2不相等

文件判断#

-e 文件：文件存在
-d 文件：文件存在且为目录
-f 文件：文件存在且为普通文件
-r 文件：文件存在且有可读权限
-w 文件：文件存在且有可写权限
-x 文件：文件存在且有可执行（或搜索）权限
-b 文件：文件存在且为块特殊文件
-c 文件：文件存在且为字符特殊文件
-g 文件：文件存在且被设置了 set-group-ID 位
-g 文件：文件存在且为有效组ID 所有
-h 文件：文件存在且为一个符号链接（与 -L 相同）
-L 文件：文件存在且为一个符号链接（与 -h 相同）
-k 文件：文件存在且被设置粘着位
-O 文件：文件存在且为有效用户ID 所有
-p 文件：文件存在且为命名管道
-s 文件：文件存在且其大小大于零
-S 文件：文件存在且为套接字
-u 文件：文件存在且被设置了 set-user-ID 位
-t FD：文件描述符 FD 在某个终端打开
文件1 -ef 文件2：文件1 和文件2 拥有相同的设备编号与 inode 编号
文件1 -nt 文件2：文件1 在修改时间上新于文件2
文件1 -ot 文件2：文件1 比文件2 更旧

逻辑判断#

! 表达式：表达式为假
表达式1 -a 表达式2：表达式1 与表达式2 皆为真
表达式1 -o 表达式2：表达式1 或表达式2 为真

分支结构#

if语句#

直接上语法：

Terminal window

1
if 条件1
2
then
3
  条件1成立时执行的命令
4
elif 条件2
5
then
6
  条件1不成立，且条件2成立时执行的命令
7
else
8
  条件1和条件2都不成立时执行的命令
9
fi # 结束if语句

这里的条件一般是一条shell命令，比如test、gcc等。如果命令的返回值为0，则条件成立。

小实验：

1
$ cat shell.sh
2
#!/bin/sh
3

4
if [ ${1} -gt ${2} ]  # 判断${1}是否大于${2}
5
then
6
  echo 'num_1 > num_2'
7
elif [ ${1} -eq ${2} ]  # 判断${1}是否等于${2}
8
then
9
  echo 'num_1 = num_2'
10
else
11
  echo 'num_1 < num_2'
12
fi
13

14
$ ./shell.sh 12 12
15
num_1 = num_2
16
$ ./shell.sh 12 11
17
num_1 > num_2
18
$ ./shell.sh 12 13
19
num_1 < num_2

展开收起

case语句#

语法：

Terminal window

1
case 字符串 in
2
模式1)
3
  # 模式1能匹配字符串时执行的命令
4
  ;; # 表示结束
5
模式2)
6
  # 模式2能匹配字符串时执行的命令
7
  ;; # 结束
8
*)
9
  # 以上模式都不匹配时执行的命令
10
  ;; # 结束
11
esac # 结束case语句

case语句只能对字符串进行判断，这里的模式是指正则表达式。

循环结构#

for语句#

语法：

Terminal window

1
for VAR in item1 item2 .... itemN
2
do
3
  # 循环内的命令
4
done

举个栗子：

Terminal window

1
$ cat shell.sh
2

3
for VAR in aaa bbb ccc
4
do
5
  echo ${VAR}
6
done
7

8
$ bash shell.sh
9
aaa
10
bbb
11
ccc

然后再介绍几种shell里与for语句搭配使用的形式。

{s..e}：用来生成从s到e的序列，s和e可以是整数，也可以是大小写字母。
Terminal window
```
1
$ echo {-3..12}
2
-3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12
3
$ echo {a..z}
4
a b c d e f g h i j k l m n o p q r s t u v w x y z
```
这里要注意的是，s和e中间有两个点，多一个或少一个都不行。

如果s和e是整数的话，可以在s和e前面加0，达到自动用0补全的效果，比如：
Terminal window
```
1
$ echo {001..012}
2
001 002 003 004 005 006 007 008 009 010 011 012
```
这个和for循环搭配使用，就可以从s循环到e了，举个栗子：
Terminal window
```
1
$ cat shell.sh
2

3
for i in {01..04}
4
do
5
  echo "str_${i}"
6
done
7

8
$ bash shell.sh
9
str_01
10
str_02
11
str_03
12
str_04
```

`命令`或者$(命令)：用for语句来循环shell命令的输出，下面的例子用for语句输出当前目录的所有文件：

Terminal window

1
for FILE_NAME in `ls`
2
do
3
  echo ${FILE_NAME}
4
done

这里再重点介绍一下seq命令，seq命令也是用来生成序列的，与{s..e}不同的是，seq可以生成浮点数序列，但是不能生成大小写字母序列，用法有三种，如下：

seq [选项]… 尾数
seq [选项]… 首数尾数
seq [选项]… 首数增量尾数

首数默认是1，增量默认也是1，可用的选项有三个：

选项	描述
-f	指定生成的序列中每个数字的格式，指定方式和c语言的printf函数方式相同，比如`%2.1f`，要注意的是只能用`%f`，`%d`和`%lf`都不行。
-s	指定分隔数字的字符串，默认是换行`\n`。
-w	通过填充前导零来均衡宽度，这个不能和`-f`同时使用。

一些例子：

Terminal window展开收起

1
$ seq 3 # 只有一个数字的，生成从1到该数字的序列，默认增量是1
2
1
3
2
4
3
5
$ seq -s ' ' 12  # 用空格来分隔数字
6
1 2 3 4 5 6 7 8 9 10 11 12
7
$
8
$ seq -s ' ' -3 12  # 有两个数字的，生成两个数字之间增量为1的序列
9
-3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12
10
$
11
$ seq -s ' ' -3 0.8 12 # 三个数字的
12
-3.0 -2.2 -1.4 -0.6 0.2 1.0 1.8 2.6 3.4 4.2 5.0 5.8 6.6 7.4 8.2 9.0 9.8 10.6 11.4
13
$
14
$ seq -s '__' -3 12  # 用'__'来分隔数字
15
-3__-2__-1__0__1__2__3__4__5__6__7__8__9__10__11__12
16
$
17
$ seq -s ' ' -w -3 12  # 通过填充前导零来均衡宽度
18
-3 -2 -1 00 01 02 03 04 05 06 07 08 09 10 11 12
19
$
20
$ seq -s ' ' -f %05.2f 12  # 指定数字的格式
21
01.00 02.00 03.00 04.00 05.00 06.00 07.00 08.00 09.00 10.00 11.00 12.00

展开收起

seq与for语句搭配使用：

Terminal window

1
$ cat shell.sh
2

3
for i in `seq -3 12`
4
do
5
  echo -n "${i} "
6
done
7
echo
8

9
$ bash shell.sh
10
-3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12

最后一种是for语句和路径通配符，举个栗子：

Terminal window

1
$ cat shell.sh
2
# 用for语句输出当前目录下的所有文件
3
for FILE_NAME in ./*
4
do
5
  echo -n "${FILE_NAME} "
6
done
7
echo
8

9
$ bash shell.sh
10
./a.out ./in.txt ./out.txt ./shell.sh ./test.cpp

while语句#

语法：

Terminal window

1
while 条件测试
2
do
3
  # 循环内的命令
4
done

while语句首先进行条件测试，如果条件为真，则进入循环，直到条件为假时退出循环，跟C语言的一样。while语句的一个经典的用法是搭配输入重定向，读取文件的内容，下面是一个例子：

Terminal window

1
while read VAR # 读取标准输入的一行
2
do
3
  echo ${VAR}
4
done < in.txt # 将in.txt文件重定向到标准输入

until语句#

语法：

Terminal window

1
until 条件测试
2
do
3
  # 循环内的命令
4
done

until语句在条件为假时进入循环，条件为真时退出循环，其他和while语句相同。

其他命令#

find#

find命令用于查找文件，这里简单的列出一些常用的用法，更详细的用法可以查manpages。

根据文件名查找#

语法find 查找的路径 -name pattern，查找文件名与模式pattern相匹配的文件。比如查找当前目录下所有以’.sh’结尾的文件。

Terminal window

1
find ./ -name "*.sh"

根据正则表达式查找#

语法find 查找的路径 -regex pattern，查找文件名与正则表达式pattern相匹配的文件。比如查找当前目录下所有以’test’开头的文件。

Terminal window

1
find ./ -regex '^\./test.*'

根据路径查找#

语法find 查找的路径 -path pattern，查找文件的完整路径与模式pattern相匹配的文件。与-name的区别是-name不匹配文件所在的目录，举个栗子：

Terminal window

1
$ find ./shell -name "*sh*"
2
./shell
3
./shell/test_1.sh
4
$ find ./shell -path "*sh*"
5
./shell
6
./shell/ganyuo.txt
7
./shell/test_1.sh

使用-name匹配文件’./shell/ganyuo.txt’时，只匹配文件名’ganyuo.txt’，因为’ganyuo.txt’和模式”*sh*“不匹配，所以不输出。使用-path匹配文件’./shell/ganyuo.txt’时，会匹配文件的完整路径’./shell/ganyuo.txt’，而’./shell/ganyuo.txt’和模式”*sh*“匹配成功。

根据文件类型查找#

语法find 查找的路径 -type c，查找文件文件类型是c的文件，类型包括：

b ：特殊块文件(缓冲的)
c ：特殊字符文件(不缓冲)
d ：目录
p ：命名管道(FIFO)
f ：普通文件
l ：符号链接
s ：套接字

查找当前目录下的普通文件：

Terminal window

1
find ./ -type f

根据文件大小查找#

语法find 查找的路径 -size n[单位]，查找文件大小是n的文件，默认的单位是512字节的块，也可以使用其他单位，支持的单位有：

b ：块(512字节)
c ：字节
w ：字(2字节)
k ：千字节
M ：兆字节
G ：千兆字节

还可以在n前面加个加号和减号，加个加号表示查找文件大小大于n的文件，减号表示小于，如果不加的话则查找文件大小刚好等于n的文件。举个栗子：

Terminal window

1
# 查找当前目录下文件大小等于8个块的文件
2
find ./ -size 8b
3

4
# 查找当前目录下文件大小大于100千字节的文件（不包括等于100千字节的文件）
5
find ./ -size +100k
6

7
# 查找当前目录下文件大小小于10兆的文件（不包括等于10M的文件）
8
find ./ -size -10M

这里还有一个要注意的细节是，n必须是整数，所以低阶单位换算成高阶单位要向上取整，比如某个大小为70字节的文件，换算成块是70÷512=0.13671875块，但是用块来查找的时候，find命令将这个文件大小当做等于1个块来处理。

根据时间查找#

语法：find 查找的路径 -[时间类型][时间单位] n，参数的关键字由时间类型和时间单位组成，时间类型包括三种：

访问时间：对文件的最后一次的访问时间，用a表示。
修改时间：文件数据最后一次的修改时间，用m表示。
变化时间：文件状态(例如权限、所有者等)最后一次修改时间，用c表示。

时间单位支持两种：

min ：分钟
time ：24个小时

将三种时间类型和两种时间单位组合，可以产生6种参数：

-amin n ：对文件的最后一次的访问时间是在n分钟之前。
-atime n ：对文件的最后一次的访问时间是在n×24小时之前。
-mmin n ：文件数据最后一次的修改时间是在n分钟之前。
-mtime n ：文件数据最后一次的修改时间是在n×24小时之前。
-cmin n ：文件状态最后一次修改时间是在n分钟之前。
-ctime n ：文件状态最后一次修改时间是在n×24小时之前。

举个栗子：

Terminal window

1
# 查找当前目录下，最后一次的访问是在5分钟之前的文件。
2
find ./ -amin 5
3

4
# 查找当前目录下，文件数据最后一次的修改时间是在2×24小时之前的文件。
5
find ./ -mtime 2

如果n前面加个负号，则查找的是对应时间离现在不超过n的文件，举个栗子：

Terminal window

1
# 查找当前目录下，最后一次的访问时间离现在不超过5分钟的文件。
2
find ./ -amin -5

还可以以某个文件的最后一次修改时间作为参照，来查找文件。

-anewer file ：对文件的最后一次访问时间在file的最后一次修改时间之后。
-newer file ：文件数据最后一次的修改时间在file的最后一次修改时间之后。(注意这里前面不要加m)
-cnewer file ：文件状态最后一次修改时间在file的最后一次修改时间之后。

Terminal window

1
# 查找当前目录下，最后一次的访问时间在./test.sh文件的最后一次修改时间之后的文件。
2
find ./ -anewer ./test.sh

根据文件所有者查找#

参数：

-user uname ：文件的所有者是uname(也可以使用数字形式的用户ID)。
-group gname ：文件属于gname(也允许使用数字形式的组ID)群组。

Terminal window

1
# 查找当前目录下，文件所有者是root的文件。
2
find ./ -user root
3

4
# 查找当前目录下，文件所在群组为root的文件。
5
find ./ -group root

根据权限查找#

-perm mode ：文件的权限位恰好是mode(八进制或符号)。
-perm -mode ：mode中的所有的权限位都被设置了的文件。
-perm +mode ：mode中的任意一个的权限位被设置了的文件。

Terminal window

1
# 查找当前目录下，权限是0777的文件。
2
find ./ -perm 0777
3

4
# 查找当前目录下，文件所有者既有可写，又有可执行权限的文件。
5
find ./ -perm -0300
6

7
# 查找当前目录下，文件所有者有可写，或者有可执行权限的文件。
8
find ./ -perm +0300 # 这条命令会报错“find: 非法权限 ‘+0300’”，不知道为什么

多条件查找#

可以用与或非逻辑，查找满足多种条件的命令。

!或-not ：查找不满足条件的文件。
-a或-and ：查找两个条件都满足的文件。(默认的条件连接逻辑)
-o或-or ：查找满足任意一个条件的文件。

举个栗子：

Terminal window

1
# 查找当前目录下，除文件目录外的所有文件
2
find ./ ! -type d
3

4
# 查找当前目录下，文件大小在2M到100M之间的文件
5
find ./ -size +2M -and -size -100M
6

7
# 查找当前目录下，以.png或.jpg结尾的文件
8
find ./ -name "*.png" -or -name "*.jpg"

逻辑运算的优先级是“! > -not > 缺省与 > -a > -and > -o > -or”。如果要提高运算的优先级，可以用小括号括起来。举个栗子：

Terminal window

1
# 查找当前目录下，以.png或.jpg结尾，且大小大于1M的文件
2
find ./ \( -name "*.png" -or -name "*.jpg" \) -and -size +1M

上面的命令中，如果不加扩号，会先进行与运算，再进行或运算。加了括号以后，则优先进行括号里的或运算，再进行与运算。

要注意的是两个括号前面要加\转义，而且前后都要用空格和其他参数分开。

找到文件后执行命令#

find命令可以用-exec和-ok参数，在找到的文件后执行特定的命令。举个栗子：

Terminal window

1
# 查找当前目录下以.sh结尾的文件，并将找到的文件移动到./shell/目录下
2
find ./ -name "*.sh" -exec mv {} ./shell/ \;

上述命令中，{}表示找到的文件，\;表示命令的结束。

find命令中，-exec和-ok的区别是，使用-ok在每次执行命令前会进行确认是否执行，-exec则直接执行，不确认。

如果在对找到的文件要执行多条命令，可以使用多次-exec或-ok，举个栗子：

Terminal window

1
# 将当前目录下的文件输出两遍
2
find ./ -exec echo {} \; -exec echo {} \;

sed#

还没学会

awk#

awk是一个文本分析工具，用于分割处理文本内容。其主要工作流程是：将输入内容以记录为单位，逐个记录读入，用域分割字符串将每个记录分割成多个子字符串，分割后的这些子字符串叫作域，然后用处理指令对分割后的域进行处理。

awk有三种方式调用方式：

命令行方式。语法：awk [-F 域分割字符串] 处理指令输入文件。
shell脚本方式。将所有的处理指令插入一个文件，并使awk程序可执行，然后awk命令解释器作为脚本的首行，通过键入脚本名称来调用。相当于把shell脚本首行的：#!/bin/sh，换成：#!/bin/awk。
将所有的awk命令插入一个单独文件，然后调用：awk -f awk-script-file 输入文件，其中，-f选项加载awk-script-file中的awk脚本。

实际上awk算是一种编程语言，深入研究的话，涉及的内容比较多，这里只简单介绍一下常用的用法，想深入研究的小伙伴可以去看GNU的官方文档。

记录#

在awk里，记录的分割用RS变量指定的字符分隔开来，RS默认是换行符，所以一般情况下，一条记录就是一行。可以通过在BEGIN里修改RS的值，来修改记录分隔字符，关于BEGIN，后面再说。

域#

awk对记录进行处理时，会将其分割成多个域，将分割后的域按顺序存到$1、$2、..$n变量里，$0存的是整条记录。

域分割字符串用-F加一个正则表达式来指定，不指定时，默认用空格、制表符等空白字符组成的字符串（相当于-F "[\f\n\r\t\v ]*"）作为域分割字符串。下面是一个awk中分割域的例子：

Terminal window展开收起

1
$ cat ./awk_input.txt
2
12 | 24 | 48
3
4  | 8  | 6
4
5  | 11 | 17
5
10 | 20 | 30
6

7
# 使用正则表达式"[ |]*"作为域分割字符串
8
$ awk -F "[ |]*" '{ printf("%2s %2s %2s\n", $1, $2, $3); }' ./awk_input.txt
9
12 24 48
10
 4  8  6
11
 5 11 17
12
10 20 30
13

14
# 使用默认的空白字符作为域分割字符串
15
$ awk '{ printf("%2s %2s %2s\n", $1, $2, $3); }' ./awk_input.txt
16
12  | 24
17
 4  |  8
18
 5  | 11
19
10  | 20

展开收起

上面的例子中，printf是awk的一种输出语句，用法和C语言几乎一样。printf("%2s %2s %2s\n", $1, $2, $3);语句用于输出当前记录的第1、2、3个域。

第一条awk命令使用正则表达式”[ |]*“匹配每条记录，每条记录共匹配到了两个域分割字符串，所以被分割成了3个域。第二条awk命令使用默认的域分割字符串（空格、制表符等空白字符组成），共匹配到了4个域分割字符串，所以每条记录被分割成了5个域（3个整数、两个”|”）。

变量#

包括内置变量和自定义的变量。

常用的内置变量：


$n	第n个域
$0	所有域
ARGC	命令行参数个数
ARGV	命令行参数排列
ENVIRON	支持队列中系统环境变量的使用
FILENAME	awk浏览的文件名
FNR	浏览文件的记录数
FS	设置输入域分隔符，等价于命令行-F选项
NF	当前记录的域的个数
NR	已读的记录数
OFS	输出域分隔符
ORS	输出记录分隔符
RS	控制记录分隔符

自定义的变量和shell的变量很相似。举个简单的例子，将每个记录第2个域的值+1，存到变量num中，然后输出num的值：

Terminal window

1
$ cat ./awk_input.txt
2
12  24  48
3
4   8   6
4
5   11  17
5
10  20  30
6
$ awk '{ num = $2 + 1; printf("第%d行第2个域+1后的值：%d\n", NR, num); }' ./awk_input.txt
7
第1行第2个域+1后的值：25
8
第2行第2个域+1后的值：9
9
第3行第2个域+1后的值：12
10
第4行第2个域+1后的值：21

数组#

awk可以使用关联数组这种数据结构，索引可以是数字或字符串。awk关联数组不需要提前声明其大小，因为它在运行时可以自动的增大或减小。用起来和C++的map很像。

数组使用的语法格式：

1
array_name[index] = value

创建数组#

直接对数组赋值就可以创建数组了，举个栗子：

Terminal window

1
$ pwd | awk '{ arr[2] = "111"; arr["aaa"] = "222"; printf("%s %s\n", arr[2], arr["aaa"]); }'
2
111 222

上面的例子中，数组arr分别用了数字2和字符串”aaa”作为索引，数组里存的数据都是字符串。

删除数组元素#

可以使用delete语句来删除数组元素，语法格式如下：

1
delete array_name[index]

删除数组元素例子：

Terminal window

1
$ pwd | awk '{ arr[2] = "111"; printf("%s\n", arr[2]); delete arr[2]; printf("%s\n", arr[2]); }'
2
111

上面的例子中，删除arr[2]后，数组对应的值变成了空。

模式#

awk的每条处理指令包括两部分，模式和动作，模式是用来控制动作的执行的。如果没有模式的话，默认对每一条记录都执行动作，比如前面举的awk的例子，都没有指定模式这里简单介绍一下三种类型的模式：1、条件模式，2、正则表达式，3、BEGIN和END。

条件模式：顾名思义，就是对符合条件的记录才进行处理，举个例子：

Terminal window

1
$ cat ./awk_input.txt
2
12 | 24 | 48
3
4  | 8  | 6
4
5  | 11 | 17
5
10 | 20 | 30
6

7
# 这条awk指令的条件模式是"$2 > 15"，作用是只对第2个域大于15的记录执行后面的动作
8
# 第2行和第3行的第2个域都小于15，不符合条件，所以没有执行动作里的printf语句
9
$ awk -F "[ |]*" '$2 > 15 { printf("第%d行第2个域大于15\n", NR); }' ./awk_input.txt
10
第1行第2个域大于15
11
第4行第2个域大于15

正则表达式：只对能用正则表达式匹配上的行进行处理，使用正则表达式作为模式的话，正则表达式要放在两个/中间，举个例子：

Terminal window

1
$ cat ./awk_input.txt
2
12 | 24 | 48
3
4  | 8  | 6
4
5  | 11 | 17
5
10 | 20 | 30
6

7
# 这条awk指令使用正则表达式".*2.*"，意思是只对包含2的记录执行后面的动作
8
$ awk '/.*2.*/ { printf("第%d行包含2\n", NR); }' ./awk_input.txt
9
第1行包含2
10
第4行包含2

BEGIN和END是两个特殊的模式，BEGIN的作用是使后面的动作在处理所有记录前执行一次，END则是在处理完所有记录后执行一次，举个例子：

Terminal window

1
$ cat ./awk_input.txt
2
12 | 24 | 48
3
4  | 8  | 6
4
5  | 11 | 17
5
10 | 20 | 30
6

7
$ awk 'BEGIN { printf("这是BEGIN打印的\n"); } { printf("这是第%d行\n", NR); } END { printf("这是END打印的\n"); }' ./awk_input.txt
8
这是BEGIN打印的
9
这是第1行
10
这是第2行
11
这是第3行
12
这是第4行
13
这是END打印的

动作#

动作是由一些处理的指令，每个动作需要用大括号{}括起来，动作里也有选择和循环控制流，支持的控制流语句包括：

1
if (condition) statement [ else statement ]
2

3
while (condition) statement
4
do statement while (condition)
5

6
for (expr1; expr2; expr3) statement
7
for (var in array) statement
8

9
break
10
continue
11

12
delete array[index]
13
delete array
14

15
exit [ expression ]
16

17
{ statements }
18

19
switch (expression) {
20
  case value|regex : statement
21
  ...
22
  [ default: statement ]
23
}

展开收起

语法和C语言很相似，这里只介绍一下if、else和for语句，其他语句类比C语言，照着用就好了。

if语句#

if、else语句语法：

1
if(条件)
2
{
3
  动作
4
}
5
else
6
{
7
  动作
8
}

if、else语句例子：

Terminal window

1
$ cat ./awk_input.txt
2
12  24  48
3
4   8   6
4
5   11  17
5
10  20  30
6

7
$ awk '{ if($2 > 15) { printf("第%d行第2个域大于15\n", NR); } else { printf("第%d行第2个域小于等于15\n", NR); } }' ./awk_input.txt
8
第1行第2个域大于15
9
第2行第2个域小于等于15
10
第3行第2个域小于等于15
11
第4行第2个域大于15

for语句#

for语句有两种用法，一种用法和C语言相似，一种和shell里的for很相似。

for语句语法：

1
for(表达式1; 条件; 表达式2)
2
{
3
  动作
4
}
5

6
for(索引 in 数组)
7
{
8
  动作
9
}

for语句例子：

Terminal window

1
$ cat ./awk_input.txt
2
12  24  48
3
4   8   6
4
5   11  17
5
10  20  30
6

7
# 第一种for语句
8
$ awk '{ arr[NR] = $2; } END{ for(i = 1; i <= NR; i++) { printf("%s ", arr[i]); } }' ./awk_input.txt
9
24 8 11 20
10

11
# 第二种for语句
12
$ awk '{ arr[NR] = $2; } END{ for(i in arr) { printf("%s ", arr[i]); } }' ./awk_input.txt
13
24 8 11 20

上面的两个例子都是利用for语句打印所有记录第2个域的内容，需要注意的是，第二种for语句循环的是数组的索引，而不是值。

输出#

awk可以用printf和print来输出，printf用法和C语言很像，print的用法和python2的很像。

Terminal window

1
$ pwd | awk '{ printf("printf: %s\n", NR); print "print:", NR; }'
2
printf: 1  # printf的输出
3
print: 1   # print的输出

HDU-1754 I Hate It

Mon, 13 Apr 2020 15:56:34 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=1754

题意#

中文题，不解释

题目解析#

跟上一题一样，还是线段树的模板题，只不过把求区间和改成了求区间最大值。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=1754 */
2
/* AC 702MS 4060K */
3
#include <stdio.h>
4

5
const int MAX_N = 200000 + 10;
6

7
int num[MAX_N];
8
int seg_tree[4 * MAX_N];
9

10
int build(int root, int left, int right)
11
{
12
  int a, b, mid;
13

14
  if(left == right - 1)
15
  {
16
    seg_tree[root] = num[left];
17
  }
18
  else
19
  {
20
    mid = (left + right) / 2;
21
    a = build(root * 2, left, mid);
22
    b = build(root * 2 + 1, mid, right);
23
    seg_tree[root] = (a > b) ? a : b;
24
  }
25
  return seg_tree[root];
26
}
27

28
int update(int root, int left, int right, int index, int val)
29
{
30
  int a, b, mid;
31

32
  if(left == right - 1)
33
  {
34
    seg_tree[root] = val;
35
  }
36
  else
37
  {
38
    mid = (left + right) / 2;
39
    if(index < mid)
40
    {
41
      seg_tree[root * 2] = update(root * 2, left, mid, index, val);
42
    }
43
    else
44
    {
45
      seg_tree[root * 2 + 1] = update(root * 2 + 1, mid, right, index, val);
46
    }
47
    a = seg_tree[root * 2];
48
    b = seg_tree[root * 2 + 1];
49
    seg_tree[root] = (a > b) ? a : b;
50
  }
51
  return seg_tree[root];
52
}
53

54
int query(int root, int left, int right, int ql, int qr)
55
{
56
  int a, b, mid;
57

58
  if(qr <= left || right <= ql)
59
  {
60
    return 0;
61
  }
62
  else if(ql <= left && right <= qr)
63
  {
64
    return seg_tree[root];
65
  }
66
  else
67
  {
68
    mid = (left + right) / 2;
69
    a = query(root * 2, left, mid, ql, qr);
70
    b = query(root * 2 + 1, mid, right, ql, qr);
71
    return (a > b) ? a : b;
72
  }
73
}
74

75
int main()
76
{
77
  int n, m, x, y;
78
  int i, ans;
79
  char req;
80

81
  while(scanf("%d %d", &n, &m) != EOF)
82
  {
83
    for(i = 0; i < n; i++)
84
    {
85
      scanf("%d", &num[i]);
86
    }
87
    build(1, 0, n);
88

89
    for(i = 0; i < m; i++)
90
    {
91
      getchar();
92
      req = getchar();
93
      scanf("%d %d", &x, &y);
94
      x -= 1;
95
      if(req == 'Q')
96
      {
97
        ans = query(1, 0, n, x, y);
98
        printf("%d\n", ans);
99
      }
100
      else if(req == 'U')
101
      {
102
        update(1, 0, n, x, y);
103
      }
104
    }
105
  }
106
  return 0;
107
}

展开收起

HDU-1166 敌兵布阵

Mon, 13 Apr 2020 12:02:13 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=1166

题意#

又是一道可以偷懒的中文题，开心！

题目解析#

这是一道线段树的模板题，而且不加延迟标记也能AC。这题也可以用树状数组来做。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=1166 */
2
/* AC 249MS 1928K */
3
#include <stdio.h>
4

5
const int MAX_N = 50000 + 10;
6

7
int num[MAX_N];
8
int seg_tree[4 * MAX_N];
9

10
int build(int root, int left, int right)
11
{
12
  int a, b, mid;
13

14
  if(left == right - 1)
15
  {
16
    seg_tree[root] = num[left];
17
  }
18
  else
19
  {
20
    mid = (left + right) / 2;
21
    a = build(root * 2, left, mid);
22
    b = build(root * 2 + 1, mid, right);
23
    seg_tree[root] = a + b;
24
  }
25
  return seg_tree[root];
26
}
27

28
int update(int root, int left, int right, int index, int add)
29
{
30
  int mid;
31

32
  if(left == right - 1)
33
  {
34
    seg_tree[root] += add;
35
  }
36
  else
37
  {
38
    mid = (left + right) / 2;
39
    if(index < mid)
40
    {
41
      seg_tree[root * 2] = update(root * 2, left, mid, index, add);
42
    }
43
    else
44
    {
45
      seg_tree[root * 2 + 1] = update(root * 2 + 1, mid, right, index, add);
46
    }
47
    seg_tree[root] = seg_tree[root * 2] + seg_tree[root * 2 + 1];
48
  }
49
  return seg_tree[root];
50
}
51

52
int query(int root, int left, int right, int ql, int qr)
53
{
54
  int a, b, mid;
55

56
  if(qr <= left || right <= ql)
57
  {
58
    return 0;
59
  }
60
  else if(ql <= left && right <= qr)
61
  {
62
    return seg_tree[root];
63
  }
64
  else
65
  {
66
    mid = (left + right) / 2;
67
    a = query(root * 2, left, mid, ql, qr);
68
    b = query(root * 2 + 1, mid, right, ql, qr);
69
    return a + b;
70
  }
71
}
72

73
int main()
74
{
75
  int cas, t, n, x, y;
76
  int i, ans;
77
  char req[20];
78

79
  scanf("%d", &t);
80
  for(cas = 1; cas <= t; cas++)
81
  {
82
    scanf("%d", &n);
83
    for(i = 0; i < n; i++)
84
    {
85
      scanf("%d", &num[i]);
86
    }
87
    build(1, 0, n);
88

89
    printf("Case %d:\n", cas);
90
    while(getchar(), scanf("%s", req) != EOF)
91
    {
92
      if(req[0] == 'E')
93
      {
94
        break;
95
      }
96
      scanf("%d %d", &x, &y);
97
      x -= 1;
98
      if(req[0] == 'Q')
99
      {
100
        ans = query(1, 0, n, x, y);
101
        printf("%d\n", ans);
102
      }
103
      else if(req[0] == 'A')
104
      {
105
        update(1, 0, n, x, y);
106
      }
107
      else if(req[0] == 'S')
108
      {
109
        update(1, 0, n, x, -y);
110
      }
111
    }
112
  }
113
  return 0;
114
}

展开收起

POJ-1287 Networking

Fri, 10 Apr 2020 08:57:52 GMT

题目#

http://poj.org/problem?id=1287

题意#

给出P个节点和R条边的无向图，求最小生成树。

题目解析#

最小生成树的模板题，可以用Prim算法或者Kruskal算法求解，Prim算法适合稠密图（点少边多），Kruskal算法适合稀疏图（点多边少）。

代码#

Prim算法

1
/* http://poj.org/problem?id=1287 */
2
/* AC 16MS 380K */
3
#include <stdio.h>
4
#include <string.h>
5

6
const int MAX_N = 50 + 10;
7

8
int prim(int mp[][MAX_N], int n)
9
{
10
  int i, j, k, min, ans;
11
  int book[MAX_N];
12
  int tree[MAX_N];
13
  int dist[MAX_N];
14

15
  for(i = 1; i < n; i++)
16
  {
17
    book[i] = 0;
18
    tree[i] = 0;
19
    dist[i] = mp[0][i];
20
  }
21
  book[0] = 1;
22
  tree[0] = -1;
23

24
  ans = 0;
25
  for(i = 1; i < n; i++)
26
  {
27
    min = 0x1f1f1f1f;
28
    k = -1;
29
    for(j = 1; j < n; j++)
30
    {
31
      if(book[j] == 0 && min > dist[j])
32
      {
33
        k = j;
34
        min = dist[j];
35
      }
36
    }
37
    if(k == -1)
38
    {
39
      return -1;
40
    }
41
    book[k] = 1;
42
    ans += mp[tree[k]][k];
43
    for(j = 1; j < n; j++)
44
    {
45
      if(book[j] == 0 && mp[k][j] < dist[j])
46
      {
47
        dist[j] = mp[k][j];
48
        tree[j] = k;
49
      }
50
    }
51
  }
52
  return ans;
53
}
54

55
int main()
56
{
57
  int n, m;
58
  int i, a, b, w, ans;
59
  int mp[MAX_N][MAX_N];
60

61
  while(scanf("%d", &n) != EOF && n > 0)
62
  {
63
    scanf("%d", &m);
64
    memset(mp, 0x1f, sizeof(mp));
65
    for(i = 0; i < m; i++)
66
    {
67
      scanf("%d %d %d", &a, &b, &w);
68
      a -= 1;
69
      b -= 1;
70
      if(w < mp[a][b])
71
      {
72
        mp[a][b] = w;
73
        mp[b][a] = w;
74
      }
75
    }
76

77
    ans = prim(mp, n);
78
    printf("%d\n", ans);
79
  }
80
  return 0;
81
}

展开收起

Kruskal算法

1
/* http://poj.org/problem?id=1287 */
2
/* AC 16MS 400K */
3
#include <stdio.h>
4
#include <algorithm>
5

6
using namespace std;
7

8
const int MAX_N = 50 + 10;
9

10
typedef struct edge
11
{
12
  int a, b, w;
13
} edge;
14

15
int cmp(edge a, edge b)
16
{
17
  return a.w < b.w;
18
}
19

20
int find_root(int set[], int i)
21
{
22
  if(set[i] != i)
23
  {
24
    set[i] = find_root(set, set[i]);
25
  }
26
  return set[i];
27
}
28

29
int kruskal(edge e[], int n, int m)
30
{
31
  int i, k, ar, br;
32
  int ans = 0;
33
  int set[MAX_N];
34

35
  sort(e, e + m, cmp);
36
  for(i = 0; i < MAX_N; i++)
37
  {
38
    set[i] = i;
39
  }
40
  k = 1;
41
  for(i = 0; i < m && k < n; i++)
42
  {
43
    ar = find_root(set, e[i].a);
44
    br = find_root(set, e[i].b);
45
    if(ar != br)
46
    {
47
      set[ar] = br;
48
      ans += e[i].w;
49
      k++;
50
    }
51
  }
52
  if(k < n)
53
  {
54
    return -1;
55
  }
56
  return ans;
57
}
58

59
int n, m;
60
edge e[MAX_N * MAX_N];
61

62
int main()
63
{
64
  int i, a, b, w, ans;
65

66
  while(scanf("%d", &n) != EOF && n > 0)
67
  {
68
    scanf("%d", &m);
69
    for(i = 0; i < m; i++)
70
    {
71
      scanf("%d %d %d", &a, &b, &w);
72
      e[i] = (edge){a, b, w};
73
    }
74

75
    ans = kruskal(e, n, m);
76
    printf("%d\n", ans);
77
  }
78
  return 0;
79
}

展开收起

POJ-1251 Jungle Roads

Wed, 08 Apr 2020 16:47:21 GMT

题目#

http://poj.org/problem?id=1251

题意#

给出地图上的n个村庄，村庄之间存在一些双向路径，每条路径有一个权值。需要选出一些路径，使得所有的村庄之间可以相互连通，且选出路径的权值和要最小，求出最小的权值和。

题目解析#

最小生成树的模板题，可以用Prim算法或者Kruskal算法求解，这里用的是Kruskal算法。

有个奇怪的问题，用c语言的scanf()来输入字符的话会Runtime Error，用c++的cin就没问题。

代码#

1
/* http://poj.org/problem?id=1251 */
2
/* AC 0MS 716K */
3
#include <stdio.h>
4
#include <iostream>
5
#include <algorithm>
6

7
using namespace std;
8

9
const int MAX_N = 30;
10

11
typedef struct edge
12
{
13
  int a, b, w;
14
} edge;
15

16
int cmp(edge a, edge b)
17
{
18
  return a.w < b.w;
19
}
20

21
int find_root(int set[], int i)
22
{
23
  if(set[i] != i)
24
  {
25
    set[i] = find_root(set, set[i]);
26
  }
27
  return set[i];
28
}
29

30
int kruskal(edge e[], int n, int m)
31
{
32
  int i, k, ar, br;
33
  int ans = 0;
34
  int set[MAX_N];
35

36
  sort(e, e + m, cmp);
37
  for(i = 0; i < MAX_N; i++)
38
  {
39
    set[i] = i;
40
  }
41
  k = 1;
42
  for(i = 0; i < m && k < n; i++)
43
  {
44
    ar = find_root(set, e[i].a);
45
    br = find_root(set, e[i].b);
46
    if(ar != br)
47
    {
48
      set[ar] = br;
49
      ans += e[i].w;
50
      k++;
51
    }
52
  }
53
  if(k < n)
54
  {
55
    return -1;
56
  }
57
  return ans;
58
}
59

60
int main()
61
{
62
  int n, m;
63
  int i, j, k, w, ans;
64
  char a, b;
65
  edge e[MAX_N * MAX_N];
66

67
  // while(scanf("%d", &n) != EOF && n > 0)
68
  while(cin >> n && n > 0)
69
  {
70
    m = 0;
71
    for(i = 0; i < n - 1; i++)
72
    {
73
      // getchar();
74
      // scanf("%c %d", &a, &k);
75
      cin >> a >> k;
76
      for(j = 0; j < k; j++)
77
      {
78
        // getchar();
79
        // scanf("%c %d", &b, &w);
80
        cin >> b >> w;
81
        e[m] = (edge){a - 'A', b - 'A', w};
82
        m++;
83
      }
84
    }
85

86
    ans = kruskal(e, n, m);
87
    printf("%d\n", ans);
88
  }
89
  return 0;
90
}
91

92
/*
93
9
94
A 2 B 12 I 25
95
B 3 C 10 H 40 I 8
96
C 2 D 18 G 55
97
D 1 E 44
98
E 2 F 60 G 38
99
F 0
100
G 1 H 35
101
H 1 I 35
102
3
103
A 2 B 10 C 40
104
B 1 C 20
105
0
106

107
*/

展开收起

POJ-1611 The Suspects

Tue, 07 Apr 2020 18:06:14 GMT

题目#

http://poj.org/problem?id=1611

题意#

有n个学生和m个团队，学生编号为0～n，一个学生可以属于多个团体。团体内如果有一个学生被怀疑感染了病毒，那么团体内所有学生都会被怀疑感染了病毒，初始时假设只有0号学生被怀疑感染了病毒，问一共有多少人会被怀疑感染了病毒。

题目解析#

可以用并查集来解决，首先0号学生属于0号集合，对于每个团体，找到所有成员所在的集合编号，如果有一个成员属于0号集合，则把所有成员都合并到0号集合，如果没有成员属于0号集合，则将所有成员所属的集合合并成一个集合，集合编号任意。

代码#

1
/* http://poj.org/problem?id=1611 */
2
/* AC 16MS 464K */
3
#include <stdio.h>
4

5
const int MAX_N = 30000 + 10;
6
const int MAX_M = 500 + 10;
7

8
int find_root(int set[], int i)
9
{
10
  if(set[i] != i)
11
  {
12
    set[i] = find_root(set, set[i]);
13
  }
14
  return set[i];
15
}
16

17
int main()
18
{
19
  int n, m;
20
  int i, j, k, num, ar, br, ans;
21
  int set[MAX_N];
22

23
  while(scanf("%d %d", &n, &m) != EOF && (n != 0 || m != 0))
24
  {
25
    for(i = 0; i < n; i++)
26
    {
27
      set[i] = i;
28
    }
29
    for(i = 0; i < m; i++)
30
    {
31
      scanf("%d", &k);
32
      if(k != 0)
33
      {
34
        scanf("%d", &num);
35
        ar = find_root(set, num);
36
      }
37
      for(j = 1; j < k; j++)
38
      {
39
        scanf("%d", &num);
40
        br = find_root(set, num);
41
        if(br == 0)
42
        {
43
          set[ar] = br;
44
          ar = 0;
45
        }
46
        else
47
        {
48
          set[br] = ar;
49
        }
50
      }
51
    }
52
    ans = 0;
53
    for(i = 0; i < n; i++)
54
    {
55
      ar = find_root(set, i);
56
      if(ar == 0)
57
      {
58
        ans++;
59
      }
60
    }
61
    printf("%d\n", ans);
62
  }
63
  return 0;
64
}

展开收起

POJ-2236 Wireless Network

Fri, 03 Apr 2020 10:31:09 GMT

题目#

http://poj.org/problem?id=2236

题意#

网断了！要把网络修好，电脑是通过无线来通信的，通信范围是d。也就是如果两台电脑没坏，且之间的距离小于d，那这两台电脑就可以相互通信。

一共有n台电脑，初始时每台电脑都是坏的，首先给出每台电脑的坐标，然后每次可以进行两种操作：

‘O’操作，修好一台电脑
‘S’操作，测试两台电脑是否可以通信

输出所有的测试结果，如果可以通信输出“SUCCESS”，否则输出“FAIL”。

题目解析#

简单的并查集问题，对于’O’操作，遍历所有已经修好的电脑，如果之间的距离小于d，就合并。对于’S’操作，判断两台电脑是否在一个集合里。

注意’O’和’S’的输入，会接收终端的换行符。

代码#

1
/* http://poj.org/problem?id=2236 */
2
/* AC 3329MS 328K */
3
#include <stdio.h>
4
#include <math.h>
5

6
const int MAX_N = 1000 + 10;
7

8
typedef struct point
9
{
10
  int x, y;
11
  double distance(point p)
12
  {
13
    return sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
14
  }
15
} point;
16

17
int find_root(int set[], int i)
18
{
19
  if(set[i] != i)
20
  {
21
    set[i] = find_root(set, set[i]);
22
  }
23
  return set[i];
24
}
25

26
int main()
27
{
28
  int n, d;
29
  char opt;
30
  int i, j, a, b, ar, br;
31
  int set[MAX_N], book[MAX_N];
32
  point p[MAX_N];
33

34
  scanf("%d %d", &n, &d);
35
  for(i = 1; i <= n; i++)
36
  {
37
    scanf("%d %d", &p[i].x, &p[i].y);
38
    set[i] = i;
39
    book[i] = 0;
40
  }
41
  while(scanf("%c", &opt) != EOF)
42
  {
43
    if(opt == 'O')
44
    {
45
      scanf("%d", &a);
46
      ar = find_root(set, a);
47
      for(i = 1; i <= n; i++)
48
      {
49
        if(book[i] == 1 && p[i].distance(p[a]) <= (double)d)
50
        {
51
          br = find_root(set, i);
52
          set[br] = ar;
53
        }
54
      }
55
      book[a] = 1;
56
    }
57
    else if(opt == 'S')
58
    {
59
      scanf("%d %d", &a, &b);
60
      if(book[a] == 0 || book[b] == 0)
61
      {
62
        printf("FAIL\n");
63
        continue;
64
      }
65
      ar = find_root(set, a);
66
      br = find_root(set, b);
67
      if(ar == br)
68
      {
69
        printf("SUCCESS\n");
70
      }
71
      else
72
      {
73
        printf("FAIL\n");
74
      }
75
    }
76
  }
77
  return 0;
78
}

展开收起

POJ-2253 Frogger

Thu, 02 Apr 2020 17:06:58 GMT

题目#

http://poj.org/problem?id=2253

题意#

湖上有n个石头，青蛙Freddy坐在1号石头上，青蛙Fiona坐在2号石头上，青蛙Freddy想要到Fiona的2号石头上（应该是只绅士青蛙）。但是湖水被污染了，他要尽量避免游泳，因此他需要利用其他石头来中转，与普通的路径长度定义不同，这里路径的长度定义为相邻两个石头距离的最大值。题目要求找出一条最短的路径，输出路径长度。

题目解析#

解题方法与使用dijkstra算法解决普通单源最短路径问题类似，但是因为路径长度的定义不同，所以在初始化起点到其他节点的路径长度，和更新到其他点的最短路径的时候需要改一下。

代码#

1
/* http://poj.org/problem?id=2253 */
2
/* AC 0MS 336K */
3
#include <stdio.h>
4
#include <math.h>
5

6
const int MAX_N = 200 + 10;
7

8
typedef struct point
9
{
10
  int x, y;
11
  double distance(point p)
12
  {
13
    return sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
14
  }
15
} point;
16

17
int n;
18
point p[MAX_N];
19

20
double dijkstra(int start, int end)
21
{
22
  int i, j, k;
23
  double min, max;
24
  int book[MAX_N];
25
  double dist[MAX_N];
26

27
  for(i = 0; i <= n; i++)
28
  {
29
    dist[i] = p[start].distance(p[i]);
30
    book[i] = 0;
31
  }
32
  dist[start] = 0.0;
33
  book[start] = 1;
34

35
  for(i = 1; i < n; i++)
36
  {
37
    min = 1e10;
38
    for(j = 0; j < n; j++)
39
    {
40
      if(book[j] == 0 && dist[j] < min)
41
      {
42
        min = dist[j];
43
        k = j;
44
      }
45
    }
46
    if(k == end)
47
    {
48
      return dist[k];
49
    }
50
    book[k] = 1;
51
    for(j = 0; j < n; j++)
52
    {
53
      if(book[j] == 0)
54
      {
55
        /* 计算起点经过k点到达j点的路径最大值 */
56
        max = p[k].distance(p[j]);
57
        if(dist[k] > max)
58
        {
59
          max = dist[k];
60
        }
61
        if(dist[j] > max)
62
        {
63
          dist[j] = max;
64
        }
65
      }
66
    }
67
  }
68
  return -1;
69
}
70

71
int main()
72
{
73
  int i, t;
74
  double ans;
75

76
  for(t = 1; scanf("%d", &n) != EOF && n >= 2; t++)
77
  {
78
    for(i = 0; i < n; i++)
79
    {
80
      scanf("%d %d", &p[i].x, &p[i].y);
81
    }
82
    ans = dijkstra(0, 1);
83
    printf("Scenario #%d\n", t);
84
    printf("Frog Distance = %.3f\n\n", ans);
85
  }
86
  return 0;
87
}

展开收起

POJ-2387 Til the Cows Come Home

Thu, 02 Apr 2020 17:03:12 GMT

题目#

http://poj.org/problem?id=2387

题意#

给出一个有n个点的图已经某些点之间的路径，求第n个点到第1个点的最短路径。

题目解析#

标准的单源最短路径问题，可以用dijkstra算法来解决，也可以用Bellman-Ford算法和SPFA算法(可以解决含负边权的图)求解，不过我不会。小心可能会有重边。

代码#

1
/* http://poj.org/problem?id=2387 */
2
/* AC 47MS 4332K */
3
#include <stdio.h>
4
#include <string.h>
5

6
const int MAX_N = 1000 + 10;
7

8
int n;
9
int mp[MAX_N][MAX_N];
10

11
int dijkstra(int start, int end)
12
{
13
  int i, j, k, min;
14
  int book[MAX_N];
15
  int dist[MAX_N];
16

17
  for(i = 0; i <= n; i++)
18
  {
19
    dist[i] = mp[start][i];
20
    book[i] = 0;
21
  }
22
  dist[start] = 0;
23
  book[start] = 1;
24

25
  for(i = 1; i < n; i++)
26
  {
27
    min = 0x1f1f1f1f;
28
    for(j = 0; j < n; j++)
29
    {
30
      if(book[j] == 0 && dist[j] < min)
31
      {
32
        min = dist[j];
33
        k = j;
34
      }
35
    }
36
    if(k == end)
37
    {
38
      return dist[k];
39
    }
40
    book[k] = 1;
41
    for(j = 0; j < n; j++)
42
    {
43
      if(book[j] == 0 && dist[j] > dist[k] + mp[k][j])
44
      {
45
        dist[j] = dist[k] + mp[k][j];
46
      }
47
    }
48
  }
49
  return -1;
50
}
51

52
int main()
53
{
54
  int t, a, b, w;
55
  int i, ans;
56

57
  while(scanf("%d %d", &t, &n) != EOF)
58
  {
59
    memset(mp, 0x1f, sizeof(mp));
60
    for(i = 0; i < t; i++)
61
    {
62
      scanf("%d %d %d", &a, &b, &w);
63
      a -= 1;
64
      b -= 1;
65
      if(w < mp[a][b])
66
      {
67
        mp[a][b] = w;
68
        mp[b][a] = w;
69
      }
70
    }
71
    ans = dijkstra(n - 1, 0);
72
    printf("%d\n", ans);
73
  }
74
  return 0;
75
}

展开收起

HDU-3335 Divisibility

Thu, 02 Apr 2020 17:01:49 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=3335

题意#

给出n个数，需要从里面选择一些出来，但是如果选择了某个数k的话，则能被k整除或k能整除的数都不能再选了，问最多能选择多少个数。

题目解析#

这题原理不是太懂，参考网上大佬的解题方法AC的，方法如下：

首先建立一个n×n的整除关系矩阵，如果第i个数于第j个数有整除关系，则矩阵的第i行第j列为1，用这个矩阵来运行舞蹈链重复覆盖算法，取结果最大值作为答案。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=3335 */
2
/* AC 15MS 1252K */
3
#include <stdio.h>
4

5
const int MAX_N = 1000 + 10;
6

7
/* 舞蹈链算法，用于求重复覆盖问题 */
8
typedef struct dance_link_rep
9
{
10
  const static int MAX_ROWS = MAX_N;
11
  const static int MAX_COLS = MAX_N;
12

13
  typedef struct node
14
  {
15
    int u, d, l, r;
16
    int row, col;
17
  } node;
18

19
  int rows, cols, node_size;
20
  node nd[MAX_ROWS * MAX_COLS];
21
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
22

23
  int ans;
24

25
  void init(int rows, int cols)
26
  {
27
    int i;
28

29
    this -> rows = rows;
30
    this -> cols = cols;
31
    /* 初始化每一列的头节点 */
32
    for(i = 0; i <= cols; i++)
33
    {
34
      nd[i].u = i;
35
      nd[i].d = i;
36
      nd[i].l = i - 1;
37
      nd[i].r = i + 1;
38
      col_nds[i] = 0;
39
    }
40
    nd[0].l = cols;
41
    nd[cols].r = 0;
42
    node_size = cols + 1;
43

44
    /* 初始化每一行的行指针 */
45
    for(i = 0; i <= rows; i++)
46
    {
47
      row_head[i] = -1;
48
    }
49
  }
50

51
  void add_node(int row, int col)
52
  {
53
    /* nd[node_size]为新添加的节点 */
54
    nd[node_size].row = row;
55
    nd[node_size].col = col;
56

57
    /* 将新添加的节点与其所在的列连接 */
58
    nd[node_size].u = col;
59
    nd[node_size].d = nd[col].d;
60
    nd[nd[col].d].u = node_size;
61
    nd[col].d = node_size;
62

63
    /* 将新添加的节点与其所在的行连接 */
64
    if(row_head[row] == -1)
65
    {
66
      row_head[row] = node_size;
67
      nd[node_size].l = node_size;
68
      nd[node_size].r = node_size;
69
    }
70
    else
71
    {
72
      int row_first = row_head[row];
73
      nd[node_size].r = row_first;
74
      nd[node_size].l = nd[row_first].l;
75
      nd[nd[row_first].l].r = node_size;
76
      nd[row_first].l = node_size;
77
    }
78
    col_nds[col]++;
79
    node_size++;
80
  }
81

82
  void remove(int col)
83
  {
84
    int i;
85
    for(i = nd[col].d; i != col; i = nd[i].d)
86
    {
87
      nd[nd[i].r].l = nd[i].l;
88
      nd[nd[i].l].r = nd[i].r;
89
    }
90
  }
91

92
  void resume(int col)
93
  {
94
    int i;
95
    for(i = nd[col].u; i != col; i = nd[i].u)
96
    {
97
      nd[nd[i].l].r = i;
98
      nd[nd[i].r].l = i;
99
    }
100
  }
101

102
  int get_rows()
103
  {
104
    int i, j, k, num = 0;
105
    bool v[MAX_COLS];
106

107
    for(i = nd[0].r; i != 0; i = nd[i].r)
108
    {
109
      v[i] = true;
110
    }
111
    for(i = nd[0].r; i != 0; i = nd[i].r)
112
    {
113
      if(v[i] == false)
114
      {
115
        continue;
116
      }
117
      num++;
118
      for(j = nd[i].d; j != i; j = nd[j].d)
119
      {
120
        for(k = nd[j].r; k != j; k = nd[k].r)
121
        {
122
          v[nd[k].col] = false;
123
        }
124
      }
125
    }
126
    return num;
127
  }
128

129
  int dfs(int len)
130
  {
131
    int i, j;
132
    int res, select_col;
133

134
    int mr = get_rows();
135
    if(ans != -1 && len + mr < ans)
136
    {
137
      return -1;
138
    }
139
    /* 当前十字链表没有列 */
140
    if(nd[0].r == 0)
141
    {
142
      if(ans < len)
143
      {
144
        ans = len;
145
      }
146
      return len;
147
    }
148
    select_col = nd[0].r;
149
    for(i = nd[0].r; i != 0; i = nd[i].r)
150
    {
151
      if(nd[i].d == i)
152
      {
153
        return -1;
154
      }
155
      if(col_nds[select_col] > col_nds[i])
156
      {
157
        select_col = i;
158
      }
159
    }
160
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
161
    {
162
      remove(i);
163
      for(j = nd[i].r; j != i; j = nd[j].r)
164
      {
165
        remove(j);
166
      }
167
      dfs(len + 1);
168
      for(j = nd[i].l; j != i; j = nd[j].l)
169
      {
170
        resume(j);
171
      }
172
      resume(i);
173
    }
174
    return ans;
175
  }
176

177
  int solve()
178
  {
179
    ans = -1;
180
    dfs(0);
181
    return ans;
182
  }
183

184
} dance_link_rep;
185

186
dance_link_rep dl;
187

188
int main()
189
{
190
  int t, n;
191
  int i, j, ans;
192
  long long a[MAX_N];
193

194
  scanf("%d", &t);
195
  while(t--)
196
  {
197
    scanf("%d", &n);
198
    for(i = 1; i <= n; i++)
199
    {
200
      scanf("%lld", &a[i]);
201
    }
202

203
    dl.init(n, n);
204
    for(i = 1; i <= n; i++)
205
    {
206
      for(j = 1; j <= n; j++)
207
      {
208
        if(a[i] % a[j] == 0 || a[j] % a[i] == 0)
209
        {
210
          dl.add_node(i, j);
211
        }
212
      }
213
    }
214
    ans = dl.solve();
215
    printf("%d\n", ans);
216
  }
217
  return 0;
218
}

展开收起

HDU-4069 Squiggly Sudoku

Tue, 31 Mar 2020 15:26:52 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=4069

题意#

普通的数独问题是要求每个3×3的子矩阵里不能有相同的数字，这题将3×3的子矩阵改成了题目给定的连通区域，每个连通区域的面积为9，其他要求不变。

题目解析#

与用舞蹈链解决普通数独问题类似，求解前需要用深度优先搜索找出每个连通区域的范围，然后给每个连通区域编号，用这个编号去代替解决普通数独问题的3×3子矩阵的编号。

这题比较麻烦的是，需要判断是否有两个以上的解，所以在用舞蹈链搜索的时候记录解的个数，如果解的个数大于2个就停止搜索。这里需要注意的是，找到第一个解后需要用数组把搜索过程中选择的行保存下来，因为下一次搜索不一定能得到第二个正确答案，但是在求解的过程中会取得第一个答案选择的行覆盖掉，所以不能用搜索选择的行来作为正确答案选择的行。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=4069 */
2
/* AC 764MS 1324K */
3
#include <stdio.h>
4

5
const int MAX_N = 10;
6

7
typedef struct dance_link
8
{
9
  const static int MAX_ROWS = MAX_N * MAX_N * MAX_N;
10
  const static int MAX_COLS = 4 * MAX_N * MAX_N;
11

12
  typedef struct node
13
  {
14
    int u, d, l, r;
15
    int row, col;
16
  } node;
17

18
  int rows, cols, node_size;
19
  node nd[MAX_ROWS * 4 * MAX_N];
20
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
21
  int path[MAX_ROWS];
22

23
  int ansl, *select_rows;
24
  int ans_num;
25

26
  void init(int rows, int cols)
27
  {
28
    int i;
29

30
    this -> rows = rows;
31
    this -> cols = cols;
32
    /* 初始化每一列的头节点 */
33
    for(i = 0; i <= cols; i++)
34
    {
35
      nd[i].u = i;
36
      nd[i].d = i;
37
      nd[i].l = i - 1;
38
      nd[i].r = i + 1;
39
      col_nds[i] = 0;
40
    }
41
    nd[0].l = cols;
42
    nd[cols].r = 0;
43
    node_size = cols + 1;
44

45
    /* 初始化每一行的行指针 */
46
    for(i = 0; i <= rows; i++)
47
    {
48
      row_head[i] = -1;
49
    }
50
  }
51

52
  void add_node(int row, int col)
53
  {
54
    /* nd[node_size]为新添加的节点 */
55
    nd[node_size].row = row;
56
    nd[node_size].col = col;
57

58
    /* 将新添加的节点与其所在的列连接 */
59
    nd[node_size].u = col;
60
    nd[node_size].d = nd[col].d;
61
    nd[nd[col].d].u = node_size;
62
    nd[col].d = node_size;
63

64
    /* 将新添加的节点与其所在的行连接 */
65
    if(row_head[row] == -1)
66
    {
67
      row_head[row] = node_size;
68
      nd[node_size].l = node_size;
69
      nd[node_size].r = node_size;
70
    }
71
    else
72
    {
73
      int row_first = row_head[row];
74
      nd[node_size].r = row_first;
75
      nd[node_size].l = nd[row_first].l;
76
      nd[nd[row_first].l].r = node_size;
77
      nd[row_first].l = node_size;
78
    }
79
    col_nds[col]++;
80
    node_size++;
81
  }
82

83
  void remove(int col)
84
  {
85
    int i, j;
86

87
    /* 将第col列从十字链表里移除 */
88
    nd[nd[col].l].r = nd[col].r;
89
    nd[nd[col].r].l = nd[col].l;
90

91
    /* 将与第col列里节点有关的行移除 */
92
    for(i = nd[col].d; i != col; i = nd[i].d)
93
    {
94
      for(j = nd[i].r; j != i; j = nd[j].r)
95
      {
96
        nd[nd[j].u].d = nd[j].d;
97
        nd[nd[j].d].u = nd[j].u;
98
        col_nds[nd[j].col]--;
99
      }
100
    }
101
  }
102

103
  void resume(int col)
104
  {
105
    int i, j;
106

107
    /* 将第col列从十字链表里恢复 */
108
    nd[nd[col].l].r = col;
109
    nd[nd[col].r].l = col;
110

111
    /* 将与第col列里节点有关的行恢复 */
112
    for(i = nd[col].d; i != col; i = nd[i].d)
113
    {
114
      for(j = nd[i].r; j != i; j = nd[j].r)
115
      {
116
        nd[nd[j].u].d = j;
117
        nd[nd[j].d].u = j;
118
        col_nds[nd[j].col]++;
119
      }
120
    }
121
  }
122

123
  int dfs(int len)
124
  {
125
    int i, j;
126
    int res, select_col;
127

128
    /* 当前十字链表没有列 */
129
    if(nd[0].r == 0)
130
    {
131
      ans_num++;
132
      ansl = len;
133
      for(i = 0; i < len; i++)
134
      {
135
        select_rows[i] = path[i];
136
      }
137
      return len;
138
    }
139
    select_col = nd[0].r;
140
    for(i = nd[0].r; i != 0; i = nd[i].r)
141
    {
142
      if(nd[i].d == i)
143
      {
144
        return -1;
145
      }
146
      if(col_nds[select_col] > col_nds[i])
147
      {
148
        select_col = i;
149
      }
150
    }
151
    remove(select_col);
152
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
153
    {
154
      path[len] = nd[i].row;
155
      for(j = nd[i].r; j != i; j = nd[j].r)
156
      {
157
        remove(nd[j].col);
158
      }
159
      res = dfs(len + 1);
160
      if(res >= 0)
161
      {
162
        if(ans_num > 1)
163
        {
164
          return res;
165
        }
166
      }
167
      for(j = nd[i].l; j != i; j = nd[j].l)
168
      {
169
        resume(nd[j].col);
170
      }
171
    }
172
    resume(select_col);
173
  }
174

175
  /*
176
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
177
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
178
  int limit：答案的上限，取-1时无上限，默认为-1。
179
  */
180
  int solve(int select_rows[] = 0)
181
  {
182
    ans_num = 0;
183
    this->select_rows = select_rows;
184
    dfs(0);
185
    return ans_num;
186
  }
187

188
} dance_link;
189

190
dance_link dl;
191

192
typedef struct node
193
{
194
  int num;
195
  int grp;
196
  int dir[4];
197
} node;
198

199
node mp[MAX_N][MAX_N];
200
int dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
201

202
void dfs(int x, int y, int grp)
203
{
204
  int i;
205

206
  if(x < 0 || x >= 9 || y < 0 || y >= 9 || mp[x][y].grp != 0)
207
  {
208
    return;
209
  }
210
  mp[x][y].grp = grp;
211
  for(i = 0; i < 4; i++)
212
  {
213
    if(mp[x][y].dir[i] == 0)
214
    {
215
      dfs(x + dirs[i][0], y + dirs[i][1], grp);
216
    }
217
  }
218
}
219

220
int main()
221
{
222
  int t, cas, i, j, k, in, row, ans_num;
223
  int x[dl.MAX_ROWS], y[dl.MAX_ROWS], num[dl.MAX_ROWS], ans[dl.MAX_ROWS], ansl;
224

225
  scanf("%d", &t);
226
  for(cas = 1; cas <= t; cas++)
227
  {
228
    for(i = 0; i < 9; i++)
229
    {
230
      for(j = 0; j < 9; j++)
231
      {
232
        scanf("%d", &in);
233
        mp[i][j].num = in % 16;
234
        in = in >> 4;
235
        for(k = 0; k < 4; k++)
236
        {
237
          mp[i][j].dir[k] = in & 1;
238
          in = in >> 1;
239
        }
240
        mp[i][j].grp = 0;
241
      }
242
    }
243
    k = 1;
244
    for(i = 0; i < 9; i++)
245
    {
246
      for(j = 0; j < 9; j++)
247
      {
248
        if(mp[i][j].grp == 0)
249
        {
250
          dfs(i, j, k);
251
          k++;
252
        }
253
      }
254
    }
255

256
    dl.init(9 * 9 * 9, 4 * 9 * 9);
257
    row = 1;
258
    for(i = 0; i < 9; i++)
259
    {
260
      for(j = 0; j < 9; j++)
261
      {
262
        if(mp[i][j].num == 0)
263
        {
264
          for(k = 0; k < 9; k++)
265
          {
266
            dl.add_node(row, i * 9 + j + 1);
267
            dl.add_node(row, 81 + i * 9 + k + 1);
268
            dl.add_node(row, 162 + j * 9 + k + 1);
269
            dl.add_node(row, 243 + (mp[i][j].grp - 1) * 9 + k + 1);
270
            x[row] = i;
271
            y[row] = j;
272
            num[row] = k + 1;
273
            row++;
274
          }
275
        }
276
        else
277
        {
278
          k = mp[i][j].num - 1;
279
          dl.add_node(row, i * 9 + j + 1);
280
          dl.add_node(row, 81 + i * 9 + k + 1);
281
          dl.add_node(row, 162 + j * 9 + k + 1);
282
          dl.add_node(row, 243 + (mp[i][j].grp - 1) * 9 + k + 1);
283
          x[row] = i;
284
          y[row] = j;
285
          num[row] = k + 1;
286
          row++;
287
        }
288
      }
289
    }
290

291
    ans_num = dl.solve(ans);
292
    printf("Case %d:\n", cas);
293
    if(ans_num <= 0)
294
    {
295
      printf("No solution\n");
296
    }
297
    else if(ans_num == 1)
298
    {
299
      for(k = 0; k < dl.ansl; k++)
300
      {
301
        i = x[ans[k]];
302
        j = y[ans[k]];
303
        mp[i][j].num = num[ans[k]];
304
      }
305

306
      for(i = 0; i < 9; i++)
307
      {
308
        for(j = 0; j < 9; j++)
309
        {
310
          printf("%d", mp[i][j].num);
311
        }
312
        printf("\n");
313
      }
314
    }
315
    else
316
    {
317
      printf("Multiple Solutions\n");
318
    }
319
  }
320
  return 0;
321
}
322

323
/*
324
3
325
144 18 112 208 80 25 54 144 48
326
135 38 147 80 121 128 97 130 32
327
137 32 160 144 114 167 208 0 32
328
192 100 160 160 208 96 183 192 101
329
209 80 39 192 86 48 136 80 114
330
152 48 226 144 112 160 160 149 48
331
128 0 112 166 215 96 160 128 41
332
128 39 153 32 209 80 101 136 35
333
192 96 200 67 80 112 208 68 96
334

335
144 48 144 81 81 16 53 144 48
336
128 96 224 144 48 128 103 128 38
337
163 208 80 0 37 224 209 0 32
338
135 48 176 192 64 112 176 192 104
339
192 101 128 89 80 82 32 150 48
340
149 48 224 208 16 48 224 192 33
341
128 0 114 176 135 0 80 112 169
342
137 32 148 32 192 96 176 144 32
343
192 96 193 64 80 80 96 192 96
344

345
144 88 48 217 16 16 80 112 176
346
224 176 129 48 128 40 208 16 37
347
145 32 128 96 196 96 176 136 32
348
192 32 227 176 144 80 96 192 32
349
176 192 80 98 160 145 80 48 224
350
128 48 144 80 96 224 183 128 48
351
128 36 224 144 51 144 32 128 105
352
131 64 112 136 32 192 36 224 176
353
224 208 80 64 64 116 192 83 96
354

355

356
Case 1:
357
521439678
358
763895124
359
984527361
360
346182795
361
157964832
362
812743956
363
235678419
364
479216583
365
698351247
366
Case 2:
367
No solution
368
Case 3:
369
Multiple Solutions
370

371
*/

展开收起

ZOJ-3122 Sudoku

Fri, 27 Mar 2020 16:03:14 GMT

题目#

https://zoj.pintia.cn/problem-sets/91827364500/problems/91827367537

题意#

给一个16×16的矩阵，求解数独问题。

题目解析#

这题跟上一题的解法类似，只是上一题是9×9，这题是16×16，具体请参考https://nchuxw.github.io/post/poj-3074-sudoku/，题目的测试样例的输入有问题，需要改正，还有就是输出的时候最后一个测试样例不要换行，否则会Presentation Error。

代码#

1
/* https://zoj.pintia.cn/problem-sets/91827364500/problems/91827367537 */
2
/* AC 201ms  640kb */
3
#include <stdio.h>
4

5
const int MAX_N = 16;
6

7
/* 舞蹈链算法，用于求不重复精确覆盖问题 */
8
typedef struct dance_link
9
{
10
  const static int MAX_ROWS = MAX_N * MAX_N * MAX_N + 10;
11
  const static int MAX_COLS = MAX_N * MAX_N * 4 + 10;
12

13
  typedef struct node
14
  {
15
    int u, d, l, r;
16
    int row, col;
17
  } node;
18

19
  int rows, cols, node_size;
20
  node nd[(MAX_ROWS + 1) * MAX_COLS];
21
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
22

23
  bool is_min_ans;
24
  int limit;
25
  int ans, *select_rows;
26

27
  void init(int rows, int cols)
28
  {
29
    int i;
30

31
    this -> rows = rows;
32
    this -> cols = cols;
33
    /* 初始化每一列的头节点 */
34
    for(i = 0; i <= cols; i++)
35
    {
36
      nd[i].u = i;
37
      nd[i].d = i;
38
      nd[i].l = i - 1;
39
      nd[i].r = i + 1;
40
      col_nds[i] = 0;
41
    }
42
    nd[0].l = cols;
43
    nd[cols].r = 0;
44
    node_size = cols + 1;
45

46
    /* 初始化每一行的行指针 */
47
    for(i = 0; i <= rows; i++)
48
    {
49
      row_head[i] = -1;
50
    }
51
  }
52

53
  void add_node(int row, int col)
54
  {
55
    /* nd[node_size]为新添加的节点 */
56
    nd[node_size].row = row;
57
    nd[node_size].col = col;
58

59
    /* 将新添加的节点与其所在的列连接 */
60
    nd[node_size].u = col;
61
    nd[node_size].d = nd[col].d;
62
    nd[nd[col].d].u = node_size;
63
    nd[col].d = node_size;
64

65
    /* 将新添加的节点与其所在的行连接 */
66
    if(row_head[row] == -1)
67
    {
68
      row_head[row] = node_size;
69
      nd[node_size].l = node_size;
70
      nd[node_size].r = node_size;
71
    }
72
    else
73
    {
74
      int row_first = row_head[row];
75
      nd[node_size].r = row_first;
76
      nd[node_size].l = nd[row_first].l;
77
      nd[nd[row_first].l].r = node_size;
78
      nd[row_first].l = node_size;
79
    }
80
    col_nds[col]++;
81
    node_size++;
82
  }
83

84
  void remove(int col)
85
  {
86
    int i, j;
87

88
    /* 将第col列从十字链表里移除 */
89
    nd[nd[col].l].r = nd[col].r;
90
    nd[nd[col].r].l = nd[col].l;
91

92
    /* 将与第col列里节点有关的行移除 */
93
    for(i = nd[col].d; i != col; i = nd[i].d)
94
    {
95
      for(j = nd[i].r; j != i; j = nd[j].r)
96
      {
97
        nd[nd[j].u].d = nd[j].d;
98
        nd[nd[j].d].u = nd[j].u;
99
        col_nds[nd[j].col]--;
100
      }
101
    }
102
  }
103

104
  void resume(int col)
105
  {
106
    int i, j;
107

108
    /* 将第col列从十字链表里恢复 */
109
    nd[nd[col].l].r = col;
110
    nd[nd[col].r].l = col;
111

112
    /* 将与第col列里节点有关的行恢复 */
113
    for(i = nd[col].d; i != col; i = nd[i].d)
114
    {
115
      for(j = nd[i].r; j != i; j = nd[j].r)
116
      {
117
        nd[nd[j].u].d = j;
118
        nd[nd[j].d].u = j;
119
        col_nds[nd[j].col]++;
120
      }
121
    }
122
  }
123

124
  int dfs(int len)
125
  {
126
    int i, j;
127
    int res, select_col;
128

129
    /* 判断是否超过了界限 */
130
    if(limit != -1 && len > limit)
131
    {
132
      return -1;
133
    }
134
    if(is_min_ans == true && ans != -1 && len > ans)
135
    {
136
      return -1;
137
    }
138
    /* 当前十字链表没有列 */
139
    if(nd[0].r == 0)
140
    {
141
      return len;
142
    }
143
    select_col = nd[0].r;
144
    for(i = nd[0].r; i != 0; i = nd[i].r)
145
    {
146
      if(nd[i].d == i)
147
      {
148
        return -1;
149
      }
150
      if(col_nds[select_col] > col_nds[i])
151
      {
152
        select_col = i;
153
      }
154
    }
155
    remove(select_col);
156
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
157
    {
158
      if(select_rows != 0)
159
      {
160
        select_rows[len] = nd[i].row;
161
      }
162
      for(j = nd[i].r; j != i; j = nd[j].r)
163
      {
164
        remove(nd[j].col);
165
      }
166
      res = dfs(len + 1);
167
      if(res >= 0)
168
      {
169
        if(is_min_ans == false)
170
        {
171
          return res;
172
        }
173
        else if(ans < 0 || ans > res)
174
        {
175
          ans = res;
176
        }
177
      }
178
      for(j = nd[i].l; j != i; j = nd[j].l)
179
      {
180
        resume(nd[j].col);
181
      }
182
    }
183
    resume(select_col);
184
    return ans;
185
  }
186

187
  /*
188
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
189
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
190
  int limit：答案的上限，取-1时无上限，默认为-1。
191
  */
192
  int solve(bool is_min_ans = true, int select_rows[] = 0, int limit = -1)
193
  {
194
    this->is_min_ans = is_min_ans;
195
    this->select_rows = select_rows;
196
    this->limit = limit;
197
    ans = -1;
198
    ans = dfs(0);
199
    return ans;
200
  }
201

202
} dance_link;
203

204
dance_link dl;
205

206
int main()
207
{
208
  int i, j, k, t, row;
209
  char str[MAX_N + 10][MAX_N + 10];
210
  int x[dl.MAX_ROWS], y[dl.MAX_ROWS], num[dl.MAX_ROWS], ans[dl.MAX_ROWS], ansl;
211

212
  for(t = 0; ; t++)
213
  {
214
    for(i = 0; i < 16; i++)
215
    {
216
      if(scanf("%s", str[i]) == EOF)
217
      {
218
        break;
219
      }
220
    }
221
    if(i < 16)
222
    {
223
      break;
224
    }
225
    if(t != 0)
226
    {
227
      printf("\n");
228
    }
229

230
    dl.init(16 * 16 * 16, 4 * 16 * 16);
231
    row = 1;
232
    for(i = 0; i < 16; i++)
233
    {
234
      for(j = 0; j < 16; j++)
235
      {
236
        if('A' <= str[i][j] && str[i][j] <= 'Z')
237
        {
238
          k = (int)(str[i][j] - 'A');
239
          dl.add_node(row, i * 16 + j + 1);
240
          dl.add_node(row, 256 + i * 16 + k + 1);
241
          dl.add_node(row, 512 + j * 16 + k + 1);
242
          dl.add_node(row, 768 + (i / 4 * 4 + j / 4) * 16 + k + 1);
243
          // printf("(%d,%d) ", row, i * 16 + j + 1);
244
          // printf("(%d,%d) ", row, 256 + i * 16 + k + 1);
245
          // printf("(%d,%d) ", row, 512 + j * 16 + k + 1);
246
          // printf("(%d,%d)\n", row, 768 + (i / 4 * 4 + j / 4) * 16 + k + 1);
247
          x[row] = i;
248
          y[row] = j;
249
          num[row] = k;
250
          row++;
251
        }
252
        else if(str[i][j] == '-')
253
        {
254
          for(k = 0; k < 16; k++)
255
          {
256
            dl.add_node(row, i * 16 + j + 1);
257
            dl.add_node(row, 256 + i * 16 + k + 1);
258
            dl.add_node(row, 512 + j * 16 + k + 1);
259
            dl.add_node(row, 768 + (i / 4 * 4 + j / 4) * 16 + k + 1);
260
            // printf("(%d,%d) ", row, i * 16 + j + 1);
261
            // printf("(%d,%d) ", row, 256 + i * 16 + k + 1);
262
            // printf("(%d,%d) ", row, 512 + j * 16 + k + 1);
263
            // printf("(%d,%d)\n", row, 768 + (i / 4 * 4 + j / 4) * 16 + k + 1);
264
            x[row] = i;
265
            y[row] = j;
266
            num[row] = k;
267
            row++;
268
          }
269
        }
270
      }
271
    }
272
    ansl = dl.solve(false, ans);
273
    for(i = 0; i < ansl; i++)
274
    {
275
      str[x[ans[i]]][y[ans[i]]] = (char)('A' + num[ans[i]]);
276
    }
277
    for(i = 0; i < 16; i++)
278
    {
279
      str[i][16] = '\0';
280
      printf("%s\n", str[i]);
281
    }
282
  }
283

284
  return 0;
285
}
286

287
/*
288

289
--A----C-----O-I
290
-J--A-B-P-CGF-H-
291
--D--F-I-E----P-
292
-G-EL-H----M-J--
293
----E----C--G---
294
-I--K-GA-B---E-J
295
D-GP--J-F----A--
296
-E---C-B--DP--O-
297
E--F-M--D--L-K-A
298
-C--------O-I-L-
299
H-P-C--F-A--B---
300
---G-OD---J----H
301
K---J----H-A-P-L
302
--B--P--E--K--A-
303
-H--B--K--FI-C--
304
--F---C--D--H-N-
305

306
FPAHMJECNLBDKOGI
307
OJMIANBDPKCGFLHE
308
LNDKGFOIJEAHMBPC
309
BGCELKHPOFIMAJDN
310
MFHBELPOACKJGNID
311
CILNKDGAHBMOPEFJ
312
DOGPIHJMFNLECAKB
313
JEKAFCNBGIDPLHOM
314
EBOFPMIJDGHLNKCA
315
NCJDHBAEKMOFIGLP
316
HMPLCGKFIAENBDJO
317
AKIGNODLBPJCEFMH
318
KDEMJIFNCHGAOPBL
319
GLBCDPMHEONKJIAF
320
PHNOBALKMJFIDCEG
321
IAFJOECGLDPBHMNK
322

323
*/

展开收起

POJ-3074 Sudoku

Fri, 27 Mar 2020 09:41:34 GMT

题目#

http://poj.org/problem?id=3074

题意#

标准的9×9数独问题，给出一个9×9的矩阵，需要填入1到9之间的数字，使得每一行、每一列以及每一个3×3子矩阵的数字都不重复。题目给出已经填了一部分数字的矩阵，需要将剩余部分填完。

题目解析#

可以用舞蹈链的精确覆盖算法来解决数独问题。首先对于每个位置有9个可以填入的数字，共有9×9个位置，所以可以分成9×9×9=729种填充情况，每种情况对应于舞蹈链里十字链表的一行。

对于每一种填充情况，有4个约束：

1. 每个位置都要填数字，不能不填。

2. 一行不能有重复的数字。

3. 一列不能有重复的数字。

4. 每个3×3的子矩阵内不能有重复的数字。

第1种约束可以用十字链表的81(9×9个位置)列来对应，如果舞蹈链计算结果所选择的行能覆盖这81列，则说明81个位置都填了数字。第2种约束也用81列来对应，因为共有9行，要保证每行没有重复的数字，只需要每行都填9个不同的数字就行，如果这81列都被覆盖，且没有重复覆盖，就能满足第二个约束了。第3种和第4种约束与第2种类似，都分别用81列来对应。4种约束一共用4×9×9=324列来对应。

729种填充情况里，每选择一种填充情况，都会占用一个9×9里的一个位置，占用9行里某一行的一个数字、9列里某一列的一个数字，9个3×3的子矩阵里的一个数字，所以每种填充情况都会覆盖4列。因为有一部分位置已经被预先填好了，所以已经填了数字的位置和没填数字的位置，需要分开来处理，没有填数字的位置需要枚举填1～9的9种填充情况，每种填充情况将对应的4列加入十字链表了，已经填了的就直接处理对应数字的填充情况就好了。

代码#

1
/* http://poj.org/problem?id=3074 */
2
/* AC 372K  63MS */
3
#include <stdio.h>
4
#include <string.h>
5

6
const int MAX_N = 10;
7

8
/* 舞蹈链算法，用于求不重复精确覆盖问题 */
9
typedef struct dance_link
10
{
11
  const static int MAX_ROWS = MAX_N * MAX_N * MAX_N;
12
  const static int MAX_COLS = MAX_N * MAX_N * 4;
13

14
  typedef struct node
15
  {
16
    int u, d, l, r;
17
    int row, col;
18
  } node;
19

20
  int rows, cols, node_size;
21
  node nd[(MAX_ROWS + 1) * MAX_COLS + 1];
22
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
23

24
  bool is_min_ans;
25
  int limit;
26
  int ans, *select_rows;
27

28
  void init(int rows, int cols)
29
  {
30
    int i;
31

32
    this -> rows = rows;
33
    this -> cols = cols;
34
    /* 初始化每一列的头节点 */
35
    for(i = 0; i <= cols; i++)
36
    {
37
      nd[i].u = i;
38
      nd[i].d = i;
39
      nd[i].l = i - 1;
40
      nd[i].r = i + 1;
41
      col_nds[i] = 0;
42
    }
43
    nd[0].l = cols;
44
    nd[cols].r = 0;
45
    node_size = cols + 1;
46

47
    /* 初始化每一行的行指针 */
48
    for(i = 0; i <= rows; i++)
49
    {
50
      row_head[i] = -1;
51
    }
52
  }
53

54
  void add_node(int row, int col)
55
  {
56
    /* nd[node_size]为新添加的节点 */
57
    nd[node_size].row = row;
58
    nd[node_size].col = col;
59

60
    /* 将新添加的节点与其所在的列连接 */
61
    nd[node_size].u = col;
62
    nd[node_size].d = nd[col].d;
63
    nd[nd[col].d].u = node_size;
64
    nd[col].d = node_size;
65

66
    /* 将新添加的节点与其所在的行连接 */
67
    if(row_head[row] == -1)
68
    {
69
      row_head[row] = node_size;
70
      nd[node_size].l = node_size;
71
      nd[node_size].r = node_size;
72
    }
73
    else
74
    {
75
      int row_first = row_head[row];
76
      nd[node_size].r = row_first;
77
      nd[node_size].l = nd[row_first].l;
78
      nd[nd[row_first].l].r = node_size;
79
      nd[row_first].l = node_size;
80
    }
81
    col_nds[col]++;
82
    node_size++;
83
  }
84

85
  void remove(int col)
86
  {
87
    int i, j;
88

89
    /* 将第col列从十字链表里移除 */
90
    nd[nd[col].l].r = nd[col].r;
91
    nd[nd[col].r].l = nd[col].l;
92

93
    /* 将与第col列里节点有关的行移除 */
94
    for(i = nd[col].d; i != col; i = nd[i].d)
95
    {
96
      for(j = nd[i].r; j != i; j = nd[j].r)
97
      {
98
        nd[nd[j].u].d = nd[j].d;
99
        nd[nd[j].d].u = nd[j].u;
100
        col_nds[nd[j].col]--;
101
      }
102
    }
103
  }
104

105
  void resume(int col)
106
  {
107
    int i, j;
108

109
    /* 将第col列从十字链表里恢复 */
110
    nd[nd[col].l].r = col;
111
    nd[nd[col].r].l = col;
112

113
    /* 将与第col列里节点有关的行恢复 */
114
    for(i = nd[col].d; i != col; i = nd[i].d)
115
    {
116
      for(j = nd[i].r; j != i; j = nd[j].r)
117
      {
118
        nd[nd[j].u].d = j;
119
        nd[nd[j].d].u = j;
120
        col_nds[nd[j].col]++;
121
      }
122
    }
123
  }
124

125
  int dfs(int len)
126
  {
127
    int i, j;
128
    int res, select_col;
129

130
    /* 判断是否超过了界限 */
131
    if(limit != -1 && len > limit)
132
    {
133
      return -1;
134
    }
135
    if(is_min_ans == true && ans != -1 && len > ans)
136
    {
137
      return -1;
138
    }
139
    /* 当前十字链表没有列 */
140
    if(nd[0].r == 0)
141
    {
142
      return len;
143
    }
144
    select_col = nd[0].r;
145
    for(i = nd[0].r; i != 0; i = nd[i].r)
146
    {
147
      if(nd[i].d == i)
148
      {
149
        return -1;
150
      }
151
      if(col_nds[select_col] > col_nds[i])
152
      {
153
        select_col = i;
154
      }
155
    }
156
    remove(select_col);
157
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
158
    {
159
      if(select_rows != 0)
160
      {
161
        select_rows[len] = nd[i].row;
162
      }
163
      for(j = nd[i].r; j != i; j = nd[j].r)
164
      {
165
        remove(nd[j].col);
166
      }
167
      res = dfs(len + 1);
168
      if(res >= 0)
169
      {
170
        if(is_min_ans == false)
171
        {
172
          return res;
173
        }
174
        else if(ans < 0 || ans > res)
175
        {
176
          ans = res;
177
        }
178
      }
179
      for(j = nd[i].l; j != i; j = nd[j].l)
180
      {
181
        resume(nd[j].col);
182
      }
183
    }
184
    resume(select_col);
185
    return ans;
186
  }
187

188
  /*
189
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
190
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
191
  int limit：答案的上限，取-1时无上限，默认为-1。
192
  */
193
  int solve(bool is_min_ans = true, int select_rows[] = 0, int limit = -1)
194
  {
195
    this->is_min_ans = is_min_ans;
196
    this->select_rows = select_rows;
197
    this->limit = limit;
198
    ans = -1;
199
    ans = dfs(0);
200
    return ans;
201
  }
202

203
} dance_link;
204

205
dance_link dl;
206

207
int main()
208
{
209
  int i, j, k, len, r, c, row;
210
  int x[dl.MAX_ROWS], y[dl.MAX_ROWS], num[dl.MAX_ROWS], ans[dl.MAX_ROWS], ansl;
211
  char str[MAX_N * MAX_N];
212

213
  while(fgets(str, MAX_N * MAX_N, stdin) != NULL)
214
  {
215
    k = 0;
216
    for(i = 0; i < 81; i++)
217
    {
218
      if(str[i] == '.')
219
      {
220
        str[i] = 0;
221
      }
222
      else if('0' <= str[i] && str[i] <= '9')
223
      {
224
        str[i] = str[i] - '0';
225
      }
226
      else
227
      {
228
        k = 1;
229
        break;
230
      }
231
      // printf("%d ", str[i]);
232
      // if((i + 1) % 9 == 0)
233
      // {
234
      //   printf("\n");
235
      // }
236
    }
237
    // printf("\n");
238
    if(k == 1)
239
    {
240
      break;
241
    }
242

243
    dl.init(9 * 9 * 9, 4 * 9 * 9);
244
    row = 1;
245
    for(i = 0; i < 81; i++)
246
    {
247
      r = i / 9;
248
      c = i % 9;
249
      if(str[i] == 0)
250
      {
251
        for(k = 0; k < 9; k++)
252
        {
253
          dl.add_node(row, r * 9 + c + 1);
254
          dl.add_node(row, 81 + r * 9 + k + 1);
255
          dl.add_node(row, 162 + c * 9 + k + 1);
256
          dl.add_node(row, 243 + (r / 3 * 3 + c / 3) * 9 + k + 1);
257
          x[row] = r;
258
          y[row] = c;
259
          num[row] = k + 1;
260
          row++;
261
        }
262
      }
263
      else
264
      {
265
        k = str[i] - 1;
266
        dl.add_node(row, r * 9 + c + 1);
267
        dl.add_node(row, 81 + r * 9 + k + 1);
268
        dl.add_node(row, 162 + c * 9 + k + 1);
269
        dl.add_node(row, 243 + (r / 3 * 3 + c / 3) * 9 + k + 1);
270
        x[row] = r;
271
        y[row] = c;
272
        num[row] = k + 1;
273
        row++;
274
      }
275
    }
276
    ansl = dl.solve(false, ans);
277
    for(i = 0; i < ansl; i++)
278
    {
279
      r = x[ans[i]];
280
      c = y[ans[i]];
281
      k = num[ans[i]];
282
      str[r * 9 + c] = k;
283
    }
284
    // for(i = 0; i < 81; i++)
285
    // {
286
    //   printf("%d ", str[i]);
287
    //   if((i + 1) % 9 == 0)
288
    //   {
289
    //     printf("\n");
290
    //   }
291
    // }
292
    // printf("\n");
293
    for(i = 0; i < 81; i++)
294
    {
295
      printf("%d", str[i]);
296
    }
297
    printf("\n");
298
  }
299
  return 0;
300
}
301

302
/*
303

304
.2738..1..1...6735.......293.5692.8...........6.1745.364.......9518...7..8..6534.
305
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
306
end
307

308
*/

展开收起

POJ-1084 Square Destroyer

Fri, 27 Mar 2020 00:00:00 GMT

题目#

http://poj.org/problem?id=1084

题意#

给出一个用火柴拼成的n×nn \times nn×n的网格（一共需要2n(n+1)2n(n+1)2n(n+1)根火柴），按顺序给每个火柴编号，然后去掉其中kkk个火柴。问至少还需要去掉几个火柴，使得网格没有任何正方形。

题目解析#

这题可以用舞蹈链的重复覆盖算法解决，也有大佬用迭代深搜AC了。用舞蹈链的话关键在于构建覆盖关系矩阵，可以将正方形作为列，火柴作为行，如果第j个正方形的完整依赖于第i根火柴，则第i行的第j列为1，否则为0。这样题目就转化为选择最少的火柴，使得这些火柴能覆盖所有正方形，最后用使用舞蹈链重复覆盖算法模板就可以了。

比较麻烦的是，遍历所有的正方形需要枚举正方形左上角顶点坐标，然后再枚举正方形的边长，最后还要转一圈，遍历组成该正方形的所有火柴，这循环写的我想哭/(ㄒoㄒ)/~~。然后就是题目在求解前要先删除一些火柴，对于每个要删除的火柴，删的时候关键不是要删除火柴所在的行，而是要删除火柴能覆盖的正方形所对应的列。

代码#

1
#include <stdio.h>
2
#include <string.h>
3

4
const int MAX_N = 8;
5

6
/* 舞蹈链算法，用于求重复覆盖问题 */
7
typedef struct dance_link_rep
8
{
9
  const static int MAX_ROWS = 2 * MAX_N * MAX_N;
10
  const static int MAX_COLS = 2 * MAX_N * MAX_N;
11

12
  typedef struct node
13
  {
14
    int u, d, l, r;
15
    int row, col;
16
  } node;
17

18
  int rows, cols, node_size;
19
  node nd[MAX_ROWS * MAX_COLS];
20
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
21

22
  bool is_min_ans;
23
  int limit;
24
  int ans, *select_rows;
25

26
  void init(int rows, int cols)
27
  {
28
    int i;
29

30
    this -> rows = rows;
31
    this -> cols = cols;
32
    /* 初始化每一列的头节点 */
33
    for(i = 0; i <= cols; i++)
34
    {
35
      nd[i].u = i;
36
      nd[i].d = i;
37
      nd[i].l = i - 1;
38
      nd[i].r = i + 1;
39
      col_nds[i] = 0;
40
    }
41
    nd[0].l = cols;
42
    nd[cols].r = 0;
43
    node_size = cols + 1;
44

45
    /* 初始化每一行的行指针 */
46
    for(i = 0; i <= rows; i++)
47
    {
48
      row_head[i] = -1;
49
    }
50
  }
51

52
  void add_node(int row, int col)
53
  {
54
    /* nd[node_size]为新添加的节点 */
55
    nd[node_size].row = row;
56
    nd[node_size].col = col;
57

58
    /* 将新添加的节点与其所在的列连接 */
59
    nd[node_size].u = col;
60
    nd[node_size].d = nd[col].d;
61
    nd[nd[col].d].u = node_size;
62
    nd[col].d = node_size;
63

64
    /* 将新添加的节点与其所在的行连接 */
65
    if(row_head[row] == -1)
66
    {
67
      row_head[row] = node_size;
68
      nd[node_size].l = node_size;
69
      nd[node_size].r = node_size;
70
    }
71
    else
72
    {
73
      int row_first = row_head[row];
74
      nd[node_size].r = row_first;
75
      nd[node_size].l = nd[row_first].l;
76
      nd[nd[row_first].l].r = node_size;
77
      nd[row_first].l = node_size;
78
    }
79
    col_nds[col]++;
80
    node_size++;
81
  }
82

83
  void remove(int col)
84
  {
85
    int i;
86
    for(i = nd[col].d; i != col; i = nd[i].d)
87
    {
88
      nd[nd[i].r].l = nd[i].l;
89
      nd[nd[i].l].r = nd[i].r;
90
    }
91
  }
92

93
  void resume(int col)
94
  {
95
    int i;
96
    for(i = nd[col].u; i != col; i = nd[i].u)
97
    {
98
      nd[nd[i].l].r = i;
99
      nd[nd[i].r].l = i;
100
    }
101
  }
102

103
  /* 计算取得答案最少需要的行数 */
104
  int get_min_rows()
105
  {
106
    int i, j, k, num = 0;
107
    bool v[MAX_COLS];
108

109
    for(i = nd[0].r; i != 0; i = nd[i].r)
110
    {
111
      v[i] = true;
112
    }
113
    for(i = nd[0].r; i != 0; i = nd[i].r)
114
    {
115
      if(v[i] == false)
116
      {
117
        continue;
118
      }
119
      num++;
120
      for(j = nd[i].d; j != i; j = nd[j].d)
121
      {
122
        for(k = nd[j].r; k != j; k = nd[k].r)
123
        {
124
          v[nd[k].col] = false;
125
        }
126
      }
127
    }
128
    return num;
129
  }
130

131
  int dfs(int len)
132
  {
133
    int i, j;
134
    int res, select_col;
135

136
    /* 判断是否超过了界限 */
137
    int mr = get_min_rows();
138
    if(limit != -1 && len + mr > limit)
139
    {
140
      return -1;
141
    }
142
    if(is_min_ans == true && ans != -1 && len + mr >= ans)
143
    {
144
      return -1;
145
    }
146
    /* 当前十字链表没有列 */
147
    if(nd[0].r == 0)
148
    {
149
      return len;
150
    }
151
    select_col = nd[0].r;
152
    for(i = nd[0].r; i != 0; i = nd[i].r)
153
    {
154
      if(nd[i].d == i)
155
      {
156
        return -1;
157
      }
158
      if(col_nds[select_col] > col_nds[i])
159
      {
160
        select_col = i;
161
      }
162
    }
163
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
164
    {
165
      if(select_rows != 0)
166
      {
167
        select_rows[len] = nd[i].row;
168
      }
169
      remove(i);
170
      for(j = nd[i].r; j != i; j = nd[j].r)
171
      {
172
        remove(j);
173
      }
174
      res = dfs(len + 1);
175
      if(res >= 0)
176
      {
177
        if(is_min_ans == false)
178
        {
179
          return res;
180
        }
181
        else if(ans < 0 || ans > res)
182
        {
183
          ans = res;
184
        }
185
      }
186
      for(j = nd[i].l; j != i; j = nd[j].l)
187
      {
188
        resume(j);
189
      }
190
      resume(i);
191
    }
192
    return ans;
193
  }
194

195
  /*
196
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
197
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
198
  int limit：答案的上限，取-1时无上限，默认为-1。
199
  */
200
  int solve(bool is_min_ans = true, int select_rows[] = 0, int limit = -1)
201
  {
202
    this->is_min_ans = is_min_ans;
203
    this->select_rows = select_rows;
204
    this->limit = limit;
205
    ans = -1;
206
    ans = dfs(0);
207
    return ans;
208
  }
209

210
} dance_link_rep;
211

212

213
dance_link_rep dl;
214

215
int main()
216
{
217
  int t, n;
218
  int i, j, k, s, p, x, y, c, flag, ans;
219
  int rows, cols;
220
  int ds[2 * MAX_N], dst;
221
  int ms[2 * MAX_N][2 * MAX_N];
222
  int as[dl.MAX_ROWS * dl.MAX_COLS][2], ast;
223

224
  scanf("%d", &t);
225
  while(t--)
226
  {
227
    scanf("%d %d", &n, &dst);
228
    for(i = 0; i < dst; i++)
229
    {
230
      scanf("%d", &ds[i]);
231
    }
232
    memset(ms, 0, sizeof(ms));
233
    for(i = 0, c = 1; i <= 2 * n; i++)
234
    {
235
      for(j = !(i % 2); j <= 2 * n; j += 2)
236
      {
237
        ms[i][j] = c;
238
        for(s = 0; s < dst; s++)
239
        {
240
          if(c == ds[s])
241
          {
242
            ms[i][j] = -1;
243
            break;
244
          }
245
        }
246
        c++;
247
      }
248
    }
249

250
    c = 1;
251
    ast = 0;
252
    for(x = 0; x < 2 * n; x += 2)
253
    {
254
      for(y = 0; y < 2 * n; y += 2)
255
      {
256
        for(s = 1; s + x / 2 <= n && s + y / 2 <= n; s++)
257
        {
258
          k = ast;
259
          flag = 0;
260
          i = x;
261
          j = y + 1;
262
          for(p = 0; p < s; p++)
263
          {
264
            if(ms[i][j] == -1)
265
            {
266
              flag = -1;
267
            }
268
            as[k][0] = ms[i][j];
269
            as[k][1] = c;
270
            k++;
271
            j += 2;
272
          }
273
          i += 1;
274
          j -= 1;
275
          for(p = 0; p < s; p++)
276
          {
277
            if(ms[i][j] == -1)
278
            {
279
              flag = -1;
280
            }
281
            as[k][0] = ms[i][j];
282
            as[k][1] = c;
283
            k++;
284
            i += 2;
285
          }
286
          i -= 1;
287
          j -= 1;
288
          for(p = 0; p < s; p++)
289
          {
290
            if(ms[i][j] == -1)
291
            {
292
              flag = -1;
293
            }
294
            as[k][0] = ms[i][j];
295
            as[k][1] = c;
296
            k++;
297
            j -= 2;
298
          }
299
          i -= 1;
300
          j += 1;
301
          for(p = 0; p < s; p++)
302
          {
303
            if(ms[i][j] == -1)
304
            {
305
              flag = -1;
306
            }
307
            as[k][0] = ms[i][j];
308
            as[k][1] = c;
309
            k++;
310
            i -= 2;
311
          }
312
          if(flag != -1)
313
          {
314
            ast = k;
315
            c++;
316
          }
317
        }
318
      }
319
    }
320

321
    rows = 2 * n * (n + 1);
322
    cols = c - 1;
323
    dl.init(rows, cols);
324
    for(i = 0; i < ast; i++)
325
    {
326
      dl.add_node(as[i][0], as[i][1]);
327
    }
328

329
    ans = dl.solve(true, NULL, -1);
330
    printf("%d\n", ans);
331
  }
332
  return 0;
333
}

展开收起

图像内插

Mon, 23 Mar 2020 23:05:39 GMT

内插是在诸如放大、收缩、旋转和几何校正等任务中广泛应用的基本工具，是一种基本的图像重取样方法，本质上，内插是用已知数据来估计未知位置的数值的处理。本文介绍的内插主要用于调整图像的大小（收缩和放大）。

双线性内插#

双线型内插利用了源图中虚拟点四周的四个真实存在的像素，来共同决定目标图中的一个像素，使用双线性内插的缩放效果比简单的最邻近内插要好很多。计算方法：

假设原图像大小为Ws×HsW_s \times H_sWs×Hs，目标图像大小为Wd×HdW_d \times H_dWd×Hd，首先根据源图像和目标图像的尺寸比例，计算目标图像像素坐标(xd,yd)(x_d,y_d)(xd,yd)在原图像中浮点坐标(xf,yf)(x_f,y_f)(xf,yf)，计算公式如下：

xf=WsWd×xdx_f = \frac{W_s}{W_d} \times x_dxf=WdWs×xdyf=HsHd×ydy_f = \frac{H_s}{H_d} \times y_dyf=HdHs×yd

接下来在原图像中寻找离浮点坐标(xf,yf)(x_f,y_f)(xf,yf)最近的四个像素点，分别是坐标为(⌊xf⌋,⌊yf⌋)(\lfloor x_f \rfloor,\lfloor y_f \rfloor)(⌊xf⌋,⌊yf⌋)，(⌊xf+1⌋,⌊yf⌋)(\lfloor x_f + 1 \rfloor,\lfloor y_f \rfloor)(⌊xf+1⌋,⌊yf⌋)，(⌊xf⌋,⌊yf+1⌋)(\lfloor x_f \rfloor,\lfloor y_f + 1 \rfloor)(⌊xf⌋,⌊yf+1⌋)，(⌊xf+1⌋,⌊yf+1⌋)(\lfloor x_f + 1 \rfloor,\lfloor y_f + 1 \rfloor)(⌊xf+1⌋,⌊yf+1⌋)的四个像素。根据这四个像素计算出浮点坐标的像素值，再将浮点坐标的像素值作为目标图像对应位置的像素值。浮点坐标的像素值的计算方法如下：

首先，在xxx方向上进行两次线性插值计算，计算出(xf,⌊yf⌋)(x_f,\lfloor y_f \rfloor)(xf,⌊yf⌋)和(xf,⌊yf+1⌋)(x_f,\lfloor y_f + 1 \rfloor)(xf,⌊yf+1⌋)处的像素值，计算公式如下，设原图中在点(x,y)(x,y)(x,y)处的像素值为fs(x,y)f_s(x,y)fs(x,y)

fs(xf,⌊yf⌋)=(⌊xf+1⌋−xf)×fs(⌊xf⌋,⌊yf⌋)+(xf−⌊xf⌋)×fs(⌊xf+1⌋,⌊yf⌋f_s(x_f,\lfloor y_f \rfloor) = (\lfloor x_f + 1 \rfloor - x_f) \times f_s(\lfloor x_f \rfloor,\lfloor y_f \rfloor) + (x_f - \lfloor x_f \rfloor) \times f_s(\lfloor x_f + 1 \rfloor,\lfloor y_f \rfloorfs(xf,⌊yf⌋)=(⌊xf+1⌋−xf)×fs(⌊xf⌋,⌊yf⌋)+(xf−⌊xf⌋)×fs(⌊xf+1⌋,⌊yf⌋fs(xf,⌊yf+1⌋)=(⌊xf+1⌋−xf)×fs(⌊xf⌋,⌊yf+1⌋)+(xf−⌊xf⌋)×fs(⌊xf+1⌋,⌊yf+1⌋)f_s(x_f,\lfloor y_f + 1 \rfloor) = (\lfloor x_f + 1 \rfloor - x_f) \times f_s(\lfloor x_f \rfloor,\lfloor y_f + 1 \rfloor) + (x_f - \lfloor x_f \rfloor) \times f_s(\lfloor x_f + 1 \rfloor,\lfloor y_f + 1 \rfloor)fs(xf,⌊yf+1⌋)=(⌊xf+1⌋−xf)×fs(⌊xf⌋,⌊yf+1⌋)+(xf−⌊xf⌋)×fs(⌊xf+1⌋,⌊yf+1⌋)

然后利用fs(xf,⌊yf⌋)f_s(x_f,\lfloor y_f \rfloor)fs(xf,⌊yf⌋)和fs(xf,⌊yf+1⌋)f_s(x_f,\lfloor y_f + 1 \rfloor)fs(xf,⌊yf+1⌋)在yyy方向上进行一次插值计算，得出fs(xf,yf)f_s(x_f,y_f)fs(xf,yf)，计算公式如下：

fs(xf,yf)=(⌊yf+1⌋−yf)×fs(xf,⌊yf⌋)+(yf−⌊yf⌋)×fs(xf,⌊yf+1⌋)f_s(x_f,y_f) = (\lfloor y_f + 1\rfloor - y_f) \times f_s(x_f,\lfloor y_f \rfloor) + (y_f - \lfloor y_f \rfloor) \times f_s(x_f,\lfloor y_f + 1 \rfloor)fs(xf,yf)=(⌊yf+1⌋−yf)×fs(xf,⌊yf⌋)+(yf−⌊yf⌋)×fs(xf,⌊yf+1⌋)

实际上，双线性内插是根据四个像素点与浮点坐标的距离来计算四个像素点的权重，然后将四个像素点的加权平均和作为浮点坐标的像素值。图片使用双线性内插的缩放效果要优于最邻近内插，但是计算量要比最邻近内插大一点²。代码可以参考下文的 bilinear_interpolation() 函数。

双三次内插#

双三次内插的原理于双线性内插相似，都是根据浮点坐标附近的像素来计算出浮点坐标的像素值，计算时也是根据与浮点坐标之间的距离来计算附近像素点的权重，最后根据附近像素点的权重和像素值取加权平均和。与双线性内插不同的是，双三次内插计算了浮点坐标附近的16个像素点，而双线性内插只计算了4个。

双三次内插的核心问题是，如何根据像素点与浮点坐标的距离计算权重，有关双三次内插的计算方法参考自https://blog.csdn.net/qq_29058565/article/details/52769497，我偷个懒，就不再详细解释了。

与前面两种内插方法相比，双三次内插在保存细节方面比双线性内插相对要好一些，但是计算量比前两种方法都要高一些，是商业图像编辑程序如Adobe Photoshap和Corel Photopaint的标准内插方法³。

代码#

使用opencv库实现的，只能处理灰度图。

1
#include <opencv2/core.hpp>
2
#include <opencv2/highgui.hpp>
3
#include <opencv2/imgproc.hpp>
4

5
using namespace cv;
6

7
/* 最近邻内插 */
8
void nearest_interpolation(Mat src, Mat &dst, Size dst_size)
9
{
10
  int i, j, x, y;
11
  /* 计算原图像与目标图像的宽度和高度比例 */
12
  double wsd = (double)src.cols / dst_size.width;
13
  double hsd = (double)src.rows / dst_size.height;
14

15
  dst = Mat(dst_size, src.type());
16
  for(i = 0; i < dst.rows; i++)
17
  {
18
    y = hsd * i + 0.5;
19
    for(j = 0; j < dst.cols; j++)
20
    {
21
      x = wsd * j + 0.5;
22
      dst.at<uchar>(i, j) = src.at<uchar>(y, x);
23
    }
24
  }
25
}
26

27
/* 双线性内插 */
28
void bilinear_interpolation(Mat src, Mat &dst, Size dst_size)
29
{
30
  int i, j;
31
  /* 计算原图像与目标图像的宽度和高度比例 */
32
  double wsd = (double)src.cols / dst_size.width;
33
  double hsd = (double)src.rows / dst_size.height;
34
  /* 表示原图中的浮点像素 */
35
  Point2f sfp;
36
  /* 表示在原图中与浮点像素最近的四个整数坐标值(左x、右x、上y、下y) */
37
  double lx, rx, uy, dy;
38
  /* x方向的两个像素点值，xy两个方向上的像素点值 */
39
  double xf1, xf2, xyf;
40

41
  dst = Mat(dst_size, src.type());
42
  for(i = 0; i < dst.rows; i++)
43
  {
44
    sfp.y = hsd * i;
45
    for(j = 0; j < dst.cols; j++)
46
    {
47
      sfp.x = wsd * j;
48
      lx = (int)sfp.x;
49
      rx = lx + 1;
50
      uy = (int)sfp.y;
51
      dy = uy + 1;
52

53
      xf1 = (rx - sfp.x) * src.at<uchar>(uy, lx) + (sfp.x - lx) * src.at<uchar>(uy, rx);
54
      xf2 = (rx - sfp.x) * src.at<uchar>(dy, lx) + (sfp.x - lx) * src.at<uchar>(dy, rx);
55
      xyf = (dy - sfp.y) * xf1 + (sfp.y - uy) * xf2;
56
      dst.at<uchar>(i, j) = (uchar)xyf;
57
    }
58
  }
59
}
60

61
int main()
62
{
63
  Mat src, dst;
64
  Size dst_size = cv::Size(2000, 1000);
65

66
  src = cv::imread("img/img1.png", cv::IMREAD_COLOR);
67
  cvtColor(src, src, COLOR_BGR2GRAY);
68
  imshow("src", src);
69

70
  nearest_interpolation(src, dst, dst_size);
71
  imshow("nearest interpolation", dst);
72

73
  bilinear_interpolation(src, dst, dst_size);
74
  imshow("bilinear interpolation", dst);
75

76
  /* opencv的双线性内插接口 */
77
  cv::resize(src, dst, dst_size, 0, 0, INTER_LINEAR);
78
  imshow("opencv resize", dst);
79

80
  waitKey(0);
81
  return 0;
82
}

展开收起

Footnotes#

有关最近邻内插的内容参考了https://www.cnblogs.com/skyfsm/p/7578302.html ↩
有关双线性内插的内容参考了https://www.cnblogs.com/yssongest/p/5303151.html ↩
此处引用自冈萨雷斯的《数字图像处理》第三版第37页。 ↩

FZU-1686 神龙的难题

Thu, 19 Mar 2020 19:00:07 GMT

题目#

http://acm.fzu.edu.cn/problem.php?pid=1686

题意#

中文题，又可以偷懒了！

题目解析#

计算出地图上所有怪物的个数，假设为KKK个，给怪物从1到K进行编号。然后枚举每一种神龙攻击的情况，也就是枚举神龙攻击范围的左上角坐标，行坐标一共有n−n1+1n-n1+1n−n1+1种情况，列坐标一共有m−m1+1m-m1+1m−m1+1种情况，所以一共有(n−n1+1)×(m−m1+1)(n-n1+1) \times (m-m1+1)(n−n1+1)×(m−m1+1)种攻击情况，假设为P=(n−n1+1)×(m−m1+1)P=(n-n1+1) \times (m-m1+1)P=(n−n1+1)×(m−m1+1)。然后构建一个P×KP \times KP×K的矩阵MMM，然后第iii种攻击情况能攻击到第jjj个怪物，则MMM的第iii行的第jjj个元素为111，否则为000。最后用舞蹈链对MMM求重复覆盖问题就好了。

代码#

1
/* http://acm.fzu.edu.cn/problem.php?pid=1686 */
2
#include <stdio.h>
3
#include <string.h>
4

5
const int MAX_N = 17;
6

7
typedef struct dance_link
8
{
9
  const static int MAX_ROWS = MAX_N * MAX_N;
10
  const static int MAX_COLS = MAX_N * MAX_N;
11

12
  typedef struct node
13
  {
14
    int u, d, l, r;
15
    int row, col;
16
  } node;
17

18
  int rows, cols, node_size;
19
  node nd[MAX_ROWS * MAX_COLS];
20
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
21

22
  bool is_min_ans;
23
  int limit;
24
  int ans, *select_rows;
25

26
  void init(int rows, int cols)
27
  {
28
    int i;
29

30
    this -> rows = rows;
31
    this -> cols = cols;
32
    /* 初始化每一列的头节点 */
33
    for(i = 0; i <= cols; i++)
34
    {
35
      nd[i].u = i;
36
      nd[i].d = i;
37
      nd[i].l = i - 1;
38
      nd[i].r = i + 1;
39
      col_nds[i] = 0;
40
    }
41
    nd[0].l = cols;
42
    nd[cols].r = 0;
43
    node_size = cols + 1;
44

45
    /* 初始化每一行的行指针 */
46
    for(i = 0; i <= rows; i++)
47
    {
48
      row_head[i] = -1;
49
    }
50
  }
51

52
  void add_node(int row, int col)
53
  {
54
    /* nd[node_size]为新添加的节点 */
55
    nd[node_size].row = row;
56
    nd[node_size].col = col;
57

58
    /* 将新添加的节点与其所在的列连接 */
59
    nd[node_size].u = col;
60
    nd[node_size].d = nd[col].d;
61
    nd[nd[col].d].u = node_size;
62
    nd[col].d = node_size;
63

64
    /* 将新添加的节点与其所在的行连接 */
65
    if(row_head[row] == -1)
66
    {
67
      row_head[row] = node_size;
68
      nd[node_size].l = node_size;
69
      nd[node_size].r = node_size;
70
    }
71
    else
72
    {
73
      int row_first = row_head[row];
74
      nd[node_size].r = row_first;
75
      nd[node_size].l = nd[row_first].l;
76
      nd[nd[row_first].l].r = node_size;
77
      nd[row_first].l = node_size;
78
    }
79
    col_nds[col]++;
80
    node_size++;
81
  }
82

83
  void remove_rep(int col)
84
  {
85
    int i;
86
    for(i = nd[col].d; i != col; i = nd[i].d)
87
    {
88
      nd[nd[i].r].l = nd[i].l;
89
      nd[nd[i].l].r = nd[i].r;
90
    }
91
  }
92

93
  void resume_rep(int col)
94
  {
95
    int i;
96
    for(i = nd[col].u; i != col; i = nd[i].u)
97
    {
98
      nd[nd[i].l].r = i;
99
      nd[nd[i].r].l = i;
100
    }
101
  }
102

103
  /* 计算取得答案最少需要的行数 */
104
  int get_min_rows()
105
  {
106
    int i, j, k, num = 0;
107
    bool v[MAX_COLS];
108

109
    for(i = nd[0].r; i != 0; i = nd[i].r)
110
    {
111
      v[i] = true;
112
    }
113
    for(i = nd[0].r; i != 0; i = nd[i].r)
114
    {
115
      if(v[i] == false)
116
      {
117
        continue;
118
      }
119
      num++;
120
      for(j = nd[i].d; j != i; j = nd[j].d)
121
      {
122
        for(k = nd[j].r; k != j; k = nd[k].r)
123
        {
124
          v[nd[k].col] = false;
125
        }
126
      }
127
    }
128
    return num;
129
  }
130

131
  int dfs_rep(int len)
132
  {
133
    int i, j;
134
    int res, select_col;
135

136
    /* 判断是否超过了界限 */
137
    int mr = get_min_rows();
138
    if(limit != -1 && len + mr > limit)
139
    {
140
      return -1;
141
    }
142
    if(is_min_ans == true && ans != -1 && len + mr >= ans)
143
    {
144
      return -1;
145
    }
146
    /* 当前十字链表没有列 */
147
    if(nd[0].r == 0)
148
    {
149
      return len;
150
    }
151
    select_col = nd[0].r;
152
    for(i = nd[0].r; i != 0; i = nd[i].r)
153
    {
154
      if(nd[i].d == i)
155
      {
156
        return -1;
157
      }
158
      if(col_nds[select_col] > col_nds[i])
159
      {
160
        select_col = i;
161
      }
162
    }
163
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
164
    {
165
      if(select_rows != NULL)
166
      {
167
        select_rows[len] = nd[i].row;
168
      }
169
      remove_rep(i);
170
      for(j = nd[i].r; j != i; j = nd[j].r)
171
      {
172
        remove_rep(j);
173
      }
174
      res = dfs_rep(len + 1);
175
      if(res >= 0)
176
      {
177
        if(is_min_ans == false)
178
        {
179
          return res;
180
        }
181
        else if(ans < 0 || ans > res)
182
        {
183
          ans = res;
184
        }
185
      }
186
      for(j = nd[i].l; j != i; j = nd[j].l)
187
      {
188
        resume_rep(j);
189
      }
190
      resume_rep(i);
191
    }
192
    return ans;
193
  }
194

195
  /*
196
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
197
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
198
  int limit：答案的上限，取-1时无上限，默认为-1。
199
  */
200
  int solve(bool is_min_ans = true, int select_rows[] = NULL, int limit = -1)
201
  {
202
    this->is_min_ans = is_min_ans;
203
    this->select_rows = select_rows;
204
    this->limit = limit;
205
    ans = -1;
206
    ans = dfs_rep(0);
207
    return ans;
208
  }
209

210
} dance_link;
211

212
dance_link dl;
213

214
int main()
215
{
216
  int n, m, n1, m1;
217
  int i, j, k, x, y, ans;
218
  int map[MAX_N][MAX_N];
219

220
  while(scanf("%d %d", &n, &m) != EOF)
221
  {
222
    k = 0;
223
    for(i = 0; i < n; i++)
224
    {
225
      for(j = 0; j < m; j++)
226
      {
227
        scanf("%d", &map[i][j]);
228
        if(map[i][j] != 0)
229
        {
230
          k++;
231
          map[i][j] = k;
232
        }
233
      }
234
    }
235
    scanf("%d %d", &n1, &m1);
236

237
    dl.init((n - n1 + 1) * (m - m1 + 1), k);
238
    k = 0;
239
    for(x = 0; x + n1 <= n; x++)
240
    {
241
      for(y = 0; y + m1 <= m; y++)
242
      {
243
        for(i = x; i < x + n1; i++)
244
        {
245
          for(j = y; j < y + m1; j++)
246
          {
247
            if(map[i][j] != 0)
248
            {
249
              dl.add_node(k + 1, map[i][j]);
250
            }
251
          }
252
        }
253
        k++;
254
      }
255
    }
256

257
    ans = dl.solve(true);
258
    printf("%d\n", ans);
259
  }
260
  return 0;
261
}

展开收起

HDU-2295 Radar

Thu, 19 Mar 2020 18:58:57 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=2295

题意#

给出n个城市，m个雷达站，以及它们的坐标，每个雷达站有一个自身为中心的圆形覆盖范围，每个雷达站的覆盖范围半径R相等。现在要使得每个城市都能被雷达站覆盖，且最多只能启用k个雷达站，求满足条件的R的最小值。

题目解析#

二分搜索R的范围，对于每个范围的中值，先假设R等于这个中值，然后构建一个m×n的矩阵，矩阵的第i行第j列表示第i个雷达是否能覆盖第j个城市，如果能为1，否则为0。然后用舞蹈链的重复覆盖算法来，判断覆盖所有城市最少需要的雷达站个数p。最后根据p是否大于k来更新R的范围，直到小于精度值。

这里精度值最好设小一点，设成1e-6就WA了。

代码#

1
/* http://acm.hdu.edu.cn/showproblem.php?pid=2295 */
2
#include <stdio.h>
3
#include <string.h>
4
#include <math.h>
5

6
const int MAX_N = 50 + 5;
7
const double EXP = 1e-8;
8

9
typedef struct point
10
{
11
  double x, y;
12
  double distance(point b)
13
  {
14
    return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
15
  }
16
} point;
17

18
typedef struct dance_link
19
{
20
  const static int MAX_ROWS = MAX_N;
21
  const static int MAX_COLS = MAX_N;
22

23
  typedef struct node
24
  {
25
    int u, d, l, r;
26
    int row, col;
27
  } node;
28

29
  int rows, cols, node_size;
30
  node nd[MAX_ROWS * MAX_COLS];
31
  int row_head[MAX_ROWS], col_nds[MAX_COLS];
32

33
  bool is_min_ans;
34
  int limit;
35
  int ans, *select_rows;
36

37
  void init(int rows, int cols)
38
  {
39
    int i;
40

41
    this -> rows = rows;
42
    this -> cols = cols;
43
    /* 初始化每一列的头节点 */
44
    for(i = 0; i <= cols; i++)
45
    {
46
      nd[i].u = i;
47
      nd[i].d = i;
48
      nd[i].l = i - 1;
49
      nd[i].r = i + 1;
50
    }
51
    nd[0].l = cols;
52
    nd[cols].r = 0;
53
    memset(col_nds, 0, sizeof(col_nds));
54
    node_size = cols + 1;
55

56
    /* 初始化每一行的行指针 */
57
    memset(row_head, -1, sizeof(row_head));
58
  }
59

60
  void add_node(int row, int col)
61
  {
62
    /* nd[node_size]为新添加的节点 */
63
    nd[node_size].row = row;
64
    nd[node_size].col = col;
65

66
    /* 将新添加的节点与其所在的列连接 */
67
    nd[node_size].u = col;
68
    nd[node_size].d = nd[col].d;
69
    nd[nd[col].d].u = node_size;
70
    nd[col].d = node_size;
71

72
    /* 将新添加的节点与其所在的行连接 */
73
    if(row_head[row] == -1)
74
    {
75
      row_head[row] = node_size;
76
      nd[node_size].l = node_size;
77
      nd[node_size].r = node_size;
78
    }
79
    else
80
    {
81
      int row_first = row_head[row];
82
      nd[node_size].r = row_first;
83
      nd[node_size].l = nd[row_first].l;
84
      nd[nd[row_first].l].r = node_size;
85
      nd[row_first].l = node_size;
86
    }
87
    col_nds[col]++;
88
    node_size++;
89
  }
90

91
  void remove(int col)
92
  {
93
    int i;
94
    for(i = nd[col].d; i != col; i = nd[i].d)
95
    {
96
      nd[nd[i].l].r = nd[i].r;
97
      nd[nd[i].r].l = nd[i].l;
98
    }
99
  }
100

101
  void resume(int col)
102
  {
103
    int i;
104
    for(i = nd[col].d; i != col; i = nd[i].d)
105
    {
106
      nd[nd[i].l].r = i;
107
      nd[nd[i].r].l = i;
108
    }
109
  }
110

111
  /* 计算取得答案最少需要的行数 */
112
  int get_min_rows()
113
  {
114
    int i, j, k, num = 0;
115
    bool v[MAX_COLS];
116

117
    for(i = nd[0].r; i != 0; i = nd[i].r)
118
    {
119
      v[i] = true;
120
    }
121
    for(i = nd[0].r; i != 0; i = nd[i].r)
122
    {
123
      if(v[i] == false)
124
      {
125
        continue;
126
      }
127
      num++;
128
      for(j = nd[i].d; j != i; j = nd[j].d)
129
      {
130
        for(k = nd[j].r; k != j; k = nd[k].r)
131
        {
132
          v[nd[k].col] = false;
133
        }
134
      }
135
    }
136
    return num;
137
  }
138

139
  int dfs(int len)
140
  {
141
    int i, j;
142
    int res, select_col;
143

144
    /* 判断是否超过了界限 */
145
    if(limit != -1 && len + get_min_rows() > limit)
146
    {
147
      return -1;
148
    }
149
    /* 当前十字链表没有列 */
150
    if(nd[0].r == 0)
151
    {
152
      return len;
153
    }
154
    select_col = nd[0].r;
155
    for(i = nd[0].r; i != 0; i = nd[i].r)
156
    {
157
      if(nd[i].d == i)
158
      {
159
        return -1;
160
      }
161
      if(col_nds[select_col] > col_nds[i])
162
      {
163
        select_col = i;
164
      }
165
    }
166
    for(i = nd[select_col].d; i != select_col; i = nd[i].d)
167
    {
168
      if(select_rows != NULL)
169
      {
170
        select_rows[len] = nd[i].row;
171
      }
172
      remove(i);
173
      for(j = nd[i].r; j != i; j = nd[j].r)
174
      {
175
        remove(j);
176
      }
177
      res = dfs(len + 1);
178
      if(res >= 0)
179
      {
180
        if(is_min_ans == false)
181
        {
182
          return res;
183
        }
184
        else if(ans < 0 || ans > res)
185
        {
186
          ans = res;
187
        }
188
      }
189
      for(j = nd[i].l; j != i; j = nd[j].l)
190
      {
191
        resume(j);
192
      }
193
      resume(i);
194
    }
195
    return ans;
196
  }
197

198
  /*
199
  bool is_min_ans: 是否求答案最小值，如果不是，得到一个可行解就返回，默认求最小值。
200
  int select_rows[]: 用于保存选择的行，取NULL时不保存，默认取NULL。
201
  int limit：答案的上限，取-1时无上限，默认为-1。
202
  */
203
  int solve(bool is_min_ans = true, int select_rows[] = NULL, int limit = -1)
204
  {
205
    this->is_min_ans = is_min_ans;
206
    this->select_rows = select_rows;
207
    this->limit = limit;
208
    ans = -1;
209
    ans = dfs(0);
210
    return ans;
211
  }
212

213
} dance_link;
214

215
dance_link dl;
216

217
int main()
218
{
219
  int t, n, m, k;
220
  int i, j;
221
  double left, right, mid;
222
  point city[MAX_N], radar[MAX_N];
223

224
  double dist;
225
  int len;
226

227
  scanf("%d", &t);
228
  while(t--)
229
  {
230
    scanf("%d %d %d", &n, &m, &k);
231
    for(i = 0; i < n; i++)
232
    {
233
      scanf("%lf %lf", &city[i].x, &city[i].y);
234
    }
235
    for(i = 0; i < m; i++)
236
    {
237
      scanf("%lf %lf", &radar[i].x, &radar[i].y);
238
    }
239

240
    left = 0.0;
241
    right = 1500.0;
242
    while(right - left >= EXP)
243
    {
244
      mid = (right + left) / 2.0;
245
      dl.init(m, n);
246
      for(i = 0; i < m; i++)
247
      {
248
        for(j = 0; j < n; j++)
249
        {
250
          dist = radar[i].distance(city[j]);
251
          if(radar[i].distance(city[j]) <= mid)
252
          {
253
            dl.add_node(i + 1, j + 1);
254
          }
255
        }
256
      }
257
      len = dl.solve(false, NULL, k);
258
      if(len != -1 && dl.solve() <= k)
259
      {
260
        right = mid;
261
      }
262
      else
263
      {
264
        left = mid;
265
      }
266
    }
267
    printf("%.6lf\n", right);
268
  }
269
  return 0;
270
}

展开收起

ZOJ-1017 Treasure Map

Mon, 16 Mar 2020 23:26:32 GMT

题目#

https://zoj.pintia.cn/problem-sets/91827364500/problems/91827367871

题意#

给出p个小矩形和每个小矩形的左下角、右上角坐标，问能否用这些小矩形拼成一个m×n的大矩形，拼接的时候小矩形的位置不能改变，且小矩形之间不能重叠。

题目解析#

这是一个二维的精确覆盖问题，可以转化为一维来处理。对于每一个小矩形，将其能覆盖的区域赋值为1，不能覆盖的区域赋值为0，这样就构建了一个m×n的矩阵，然后将这个二维的矩阵转化为一维的向量。转化的方法就是，把矩阵的m行元素按顺利排一行，比如矩阵的第一行的第1、2、…、n-1、n个元素的作为向量的第1、2、…、n-1、n个元素，第二行的第1、2、…、n-1、n个元素作为向量的第n+1、n+2、…、2n-1、2n个元素，第i行的第j个元素的作为第i×n+j元素。接下来将p个小矩形转化成的p个向量组成一个p行m×n列的的矩阵，这样题目就转化为对这个矩阵求标准的精确覆盖问题，用舞蹈链算法处理一下就好了。

需要注意的是，这题需要求覆盖整个大矩形，最少使用的小矩形，求出可行解后需要继续搜索出最优解。

代码#

1
/* https://zoj.pintia.cn/problem-sets/91827364500/problems/91827367871 */
2
#include <stdio.h>
3
#include <string.h>
4

5
const int MAX_COLS = 30 * 30 + 10;
6
const int MAX_ROWS = 500 + 10;
7

8
typedef struct node
9
{
10
  int u, d, l, r;
11
  int row, col;
12
} node;
13

14
int rows, cols, node_size;
15
node nd[MAX_ROWS * MAX_COLS];
16
int row_head[MAX_ROWS], col_nds[MAX_COLS];
17

18
int ans;
19

20
void init()
21
{
22
  int i;
23

24
  /* 初始化每一列的头节点 */
25
  for(i = 0; i <= cols; i++)
26
  {
27
    nd[i].u = i;
28
    nd[i].d = i;
29
    nd[i].l = i - 1;
30
    nd[i].r = i + 1;
31
  }
32
  nd[0].l = cols;
33
  nd[cols].r = 0;
34
  memset(col_nds, 0, sizeof(col_nds));
35
  node_size = cols + 1;
36

37
  /* 初始化每一行的行指针 */
38
  memset(row_head, -1, sizeof(row_head));
39
}
40

41
void add_node(int row, int col)
42
{
43
  /* nd[node_size]为新添加的节点 */
44
  nd[node_size].row = row;
45
  nd[node_size].col = col;
46

47
  /* 将新添加的节点与其所在的列连接 */
48
  nd[node_size].u = col;
49
  nd[node_size].d = nd[col].d;
50
  nd[nd[col].d].u = node_size;
51
  nd[col].d = node_size;
52

53
  /* 将新添加的节点与其所在的行连接 */
54
  if(row_head[row] == -1)
55
  {
56
    row_head[row] = node_size;
57
    nd[node_size].l = node_size;
58
    nd[node_size].r = node_size;
59
  }
60
  else
61
  {
62
    int row_first = row_head[row];
63
    nd[node_size].r = row_first;
64
    nd[node_size].l = nd[row_first].l;
65
    nd[nd[row_first].l].r = node_size;
66
    nd[row_first].l = node_size;
67
  }
68
  col_nds[col]++;
69
  node_size++;
70
}
71

72
void remove(int col)
73
{
74
  int i, j;
75

76
  /* 将第col列从十字链表里移除 */
77
  nd[nd[col].l].r = nd[col].r;
78
  nd[nd[col].r].l = nd[col].l;
79

80
  /* 将与第col列里节点有关的行移除 */
81
  for(i = nd[col].d; i != col; i = nd[i].d)
82
  {
83
    for(j = nd[i].r; j != i; j = nd[j].r)
84
    {
85
      nd[nd[j].u].d = nd[j].d;
86
      nd[nd[j].d].u = nd[j].u;
87
      col_nds[nd[j].col]--;
88
    }
89
  }
90
}
91

92
void resume(int col)
93
{
94
  int i, j;
95

96
  /* 将第col列从十字链表里恢复 */
97
  nd[nd[col].l].r = col;
98
  nd[nd[col].r].l = col;
99

100
  /* 将与第col列里节点有关的行恢复 */
101
  for(i = nd[col].d; i != col; i = nd[i].d)
102
  {
103
    for(j = nd[i].r; j != i; j = nd[j].r)
104
    {
105
      nd[nd[j].u].d = j;
106
      nd[nd[j].d].u = j;
107
      col_nds[nd[j].col]++;
108
    }
109
  }
110
}
111

112
void dfs(int len)
113
{
114
  int i, j, res, select_col;
115
  int min;
116

117
  if(len >= ans)
118
  {
119
    return ;
120
  }
121
  /* 当前十字链表没有列 */
122
  if(nd[0].r == 0)
123
  {
124
    ans = len;
125
    return ;
126
  }
127
  min = MAX_ROWS;
128
  for(i = nd[0].r; i != 0; i = nd[i].r)
129
  {
130
    if(nd[i].d == i)
131
    {
132
      return ;
133
    }
134
    if(min > col_nds[i])
135
    {
136
      select_col = i;
137
      min = col_nds[i];
138
    }
139
  }
140
  remove(select_col);
141
  for(i = nd[select_col].d; i != select_col; i = nd[i].d)
142
  {
143
    for(j = nd[i].r; j != i; j = nd[j].r)
144
    {
145
      remove(nd[j].col);
146
    }
147
    dfs(len + 1);
148
    for(j = nd[i].l; j != i; j = nd[j].l)
149
    {
150
      resume(nd[j].col);
151
    }
152
  }
153
  resume(select_col);
154
}
155

156
int main()
157
{
158
  int t, n, m, p, x1, x2, y1, y2;
159
  int i, j, k, len;
160

161
  scanf("%d", &t);
162
  while(t--)
163
  {
164
    scanf("%d %d %d", &n, &m, &p);
165
    rows = p;
166
    cols = n * m;
167
    init();
168
    for(k = 0; k < p; k++)
169
    {
170
      scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
171
      for(i = y1; i < y2; i++)
172
      {
173
        for(j = x1; j < x2; j++)
174
        {
175
          add_node(k + 1, i * n + j + 1);
176
        }
177
      }
178
    }
179
    ans = MAX_ROWS;
180
    dfs(0);
181
    if(ans == MAX_ROWS)
182
    {
183
      ans = -1;
184
    }
185
    printf("%d\n", ans);
186
  }
187
  return 0;
188
}

展开收起

HUST-1017 Exact cover

Tue, 10 Mar 2020 20:45:59 GMT

题目#

http://www.hustoj.org/problem/1017

题意#

给出一个大小为n×m，只包含0和1的矩阵，需要选出矩阵中的某些行，使得这些行组成的子矩阵在每一列上有且只有一个1。

题目解析#

这题是舞蹈链的模板题，标准的精确覆盖问题。第一次接触舞蹈链算法，参考大佬的博客才看懂的，关于舞蹈链算法，参考自https://www.cnblogs.com/grenet/p/3145800.html，大佬解释的非常详细了，在此感谢万仓一黍大佬的解释，我比较懒，就不复述了。代码参考了https://www.cnblogs.com/ZShogg/p/3288980.html，也感谢Hogg大佬的代码。

代码#

1
/* http://www.hustoj.org/problem/1017 */
2
/* 测试样例通过了，因为oj的问题（HUST OJ不支持特判），无法提交 */
3
#include <stdio.h>
4
#include <string.h>
5

6
const int MAX_N = 1000 + 10;
7
const int MAX_NODE = MAX_N * 100;
8

9
typedef struct node
10
{
11
  int u, d, l, r;
12
  int row, col;
13
} node;
14

15
int n, m, node_size;
16
node nd[MAX_NODE];
17
int row_head[MAX_N];
18

19
void init()
20
{
21
  int i;
22

23
  /* 初始化每一列的头节点 */
24
  for(i = 0; i <= m; i++)
25
  {
26
    nd[i].u = i;
27
    nd[i].d = i;
28
    nd[i].l = i - 1;
29
    nd[i].r = i + 1;
30
  }
31
  nd[0].l = m;
32
  nd[m].r = 0;
33
  node_size = m + 1;
34

35
  /* 初始化每一行的行指针 */
36
  memset(row_head, -1, sizeof(row_head));
37
}
38

39
void add_node(int row, int col)
40
{
41
  /* nd[node_size]为新添加的节点 */
42
  nd[node_size].row = row;
43
  nd[node_size].col = col;
44

45
  /* 将新添加的节点与其所在的列连接 */
46
  nd[node_size].u = col;
47
  nd[node_size].d = nd[col].d;
48
  nd[nd[col].d].u = node_size;
49
  nd[col].d = node_size;
50

51
  /* 将新添加的节点与其所在的行连接 */
52
  if(row_head[row] == -1)
53
  {
54
    row_head[row] = node_size;
55
    nd[node_size].l = node_size;
56
    nd[node_size].r = node_size;
57
  }
58
  else
59
  {
60
    int row_first = row_head[row];
61
    nd[node_size].r = row_first;
62
    nd[node_size].l = nd[row_first].l;
63
    nd[nd[row_first].l].r = node_size;
64
    nd[row_first].l = node_size;
65
  }
66
  node_size++;
67
}
68

69
void remove(int col)
70
{
71
  int i, j;
72

73
  /* 将第col列从十字链表里移除 */
74
  nd[nd[col].l].r = nd[col].r;
75
  nd[nd[col].r].l = nd[col].l;
76

77
  /* 将与第col列里节点有关的行移除 */
78
  for(i = nd[col].d; i != col; i = nd[i].d)
79
  {
80
    for(j = nd[i].r; j != i; j = nd[j].r)
81
    {
82
      nd[nd[j].u].d = nd[j].d;
83
      nd[nd[j].d].u = nd[j].u;
84
    }
85
  }
86
}
87

88
void resume(int col)
89
{
90
  int i, j;
91

92
  /* 将第col列从十字链表里恢复 */
93
  nd[nd[col].l].r = col;
94
  nd[nd[col].r].l = col;
95

96
  /* 将与第col列里节点有关的行恢复 */
97
  for(i = nd[col].d; i != col; i = nd[i].d)
98
  {
99
    for(j = nd[i].r; j != i; j = nd[j].r)
100
    {
101
      nd[nd[j].u].d = j;
102
      nd[nd[j].d].u = j;
103
    }
104
  }
105
}
106

107
int dfs(int ans[], int len)
108
{
109
  int i, j, res, select_col;
110

111
  /* 当前十字链表没有列 */
112
  if(nd[0].r == 0)
113
  {
114
    return len;
115
  }
116
  for(i = nd[0].r; i != 0; i = nd[i].r)
117
  {
118
    if(nd[i].d == i)
119
    {
120
      return -1;
121
    }
122
  }
123
  select_col = nd[0].r;
124
  remove(select_col);
125
  for(i = nd[select_col].d; i != select_col; i = nd[i].d)
126
  {
127
    ans[len] = nd[i].row;
128
    for(j = nd[i].r; j != i; j = nd[j].r)
129
    {
130
      remove(nd[j].col);
131
    }
132
    res = dfs(ans, len + 1);
133
    if(res >= 0)
134
    {
135
      return res;
136
    }
137
    for(j = nd[i].l; j != i; j = nd[j].l)
138
    {
139
      resume(nd[j].col);
140
    }
141
  }
142
  resume(select_col);
143
  return -1;
144
}
145

146
int main()
147
{
148
  int i, j, k, c, len;
149
  int ans[MAX_N];
150

151
  while(scanf("%d %d", &n, &m) != EOF)
152
  {
153
    init();
154
    for(i = 1; i <= n; i++)
155
    {
156
      scanf("%d", &c);
157
      for(j = 0; j < c; j++)
158
      {
159
        scanf("%d", &k);
160
        add_node(i, k);
161
      }
162
    }
163

164
    len = dfs(ans, 0);
165
    if(len < 0)
166
    {
167
      printf("NO\n");
168
    }
169
    else
170
    {
171
      printf("%d", len);
172
      for(i = 0; i < len; i++)
173
      {
174
        printf(" %d", ans[i]);
175
      }
176
      printf("\n");
177
    }
178
  }
179

180
  return 0;
181
}
182

183
/*
184

185
6 7
186
3 1 4 7
187
2 1 4
188
3 4 5 7
189
3 3 5 6
190
4 2 3 6 7
191
2 2 7
192

193
*/

展开收起

HDU-2102 A计划

Wed, 26 Feb 2020 19:36:55 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=2102

题意#

中文题，就不解释了哈。

解题思路#

从起点开始搜索四个方向就好了，用深度优先搜索和广度优先搜索都行，遇到#就搜索另一层。需要注意的是传送到另一层后，不只是要判断是不是墙，还要判断是不是#，因为按题意来说，这种情况会一直在两层之间传送，然后走不出去，如果不特判的话，会在另一层继续搜索。

代码#

1
#include <stdio.h>
2
#include <string.h>
3

4
const int MAX_N = 12;
5

6
typedef struct node
7
{
8
  int x, y, z;
9
  int t;
10
} node;
11

12
int n, m, t;
13
char map[2][MAX_N][MAX_N];
14

15
int solve()
16
{
17
  int i, j, front, back;
18
  int book[2][MAX_N][MAX_N];
19
  node que[2 * MAX_N * MAX_N];
20
  node tep;
21
  int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
22

23
  que[0] = (node){0, 0, 0, 0};
24
  front = 0;
25
  back = 1;
26
  memset(book, 0, sizeof(book));
27
  book[0][0][0] = 1;
28
  while(front != back)
29
  {
30
    for(i = 0; i < 4; i++)
31
    {
32
      tep = que[front];
33
      tep.x += dir[i][0];
34
      tep.y += dir[i][1];
35
      tep.t++;
36
      if(tep.x < 0 || tep.x >= n || tep.y < 0 || tep.y >= m || tep.t > t)
37
      {
38
        continue;
39
      }
40
      if(map[tep.z][tep.x][tep.y] == '#')
41
      {
42
        tep.z = !tep.z;
43
      }
44
      if(map[tep.z][tep.x][tep.y] == '*' || map[tep.z][tep.x][tep.y] == '#' || book[tep.z][tep.x][tep.y] == 1)
45
      {
46
        continue;
47
      }
48
      if(map[tep.z][tep.x][tep.y] == 'P')
49
      {
50
        return tep.t;
51
      }
52
      book[tep.z][tep.x][tep.y] = 1;
53
      que[back] = tep;
54
      back++;
55
    }
56
    front++;
57
  }
58
  return 0;
59
}
60

61
int main()
62
{
63
  int c, i, ans;
64

65
  scanf("%d", &c);
66
  while(c--)
67
  {
68
    scanf("%d %d %d", &n, &m, &t);
69
    getchar();
70
    for(i = 0; i < n; i++)
71
    {
72
      scanf("%s", map[0][i]);
73
    }
74
    getchar();
75
    for(i = 0; i < n; i++)
76
    {
77
      scanf("%s", map[1][i]);
78
    }
79

80
    ans = solve();
81
    if(ans == 0)
82
    {
83
      printf("NO\n");
84
    }
85
    else
86
    {
87
      printf("YES\n");
88
    }
89
  }
90
  return 0;
91
}

展开收起

HDU-1067 Gap

Sun, 23 Feb 2020 15:45:01 GMT

题目#

http://acm.hdu.edu.cn/showproblem.php?pid=1067

题意#

首先给出28（4×7）张卡片和一个4×8的表格，每张卡片都有一个数字，分别是11～17、21～27、31～37和41～47。初始时将卡片随机放入表格里除第一列以外的其他位置，如下图：

然后将数字11的卡片放到第一列的第一行，数字21的卡片放到第一列的第二行，数字31和41的卡片类似，如下图：

接下来需要移动卡片，移动的规则是，只能将卡片移动到空白格子上，且移动到空白格子上的卡片，必须是比空白格子左边卡片上的数字大1的那张。比如上图的第一行的第二列空白格子，其左边卡片上的数字是42，那么只能将数字为43的卡片移动到该空白格子上。在移动过若干次卡片后，如果卡片的位置能变成下图所示的样子，输出最小移动的次数，否则输出-1。

解题思路#

这题要计算最小移动的次数，首先想到的是用广度优先搜索，比较麻烦的是标记每次移动后状态。可以将表格的状态转化为一个长度为28的字符串（4×7，表格第一列不会被移动，所以不用标记），然后用map的这个字符串来判断该状态是否被标记过。

代码#

1
#include <stdio.h>
2
#include <string.h>
3
#include <string>
4
#include <queue>
5
#include <map>
6

7
using namespace std;
8

9
typedef struct node
10
{
11
  char index[4];
12
  char a[30];
13
  int t;
14
} node;
15

16
int solve(node start)
17
{
18
  int i, j, k, si, di, dnum;
19
  node tep;
20
  queue<node> que;
21
  map<string, bool> mp;
22
  char end[30] =
23
  {
24
    12, 13, 14, 15, 16, 17, 1,
25
    22, 23, 24, 25, 26, 27, 1,
26
    32, 33, 34, 35, 36, 37, 1,
27
    42, 43, 44, 45, 46, 47, 1, 0
28
  };
29

30
  if(strcmp(start.a, end) == 0)
31
  {
32
    return 0;
33
  }
34
  que.push(start);
35
  mp[start.a] = true;
36
  while(que.empty() == false)
37
  {
38
    for(k = 0; k < 4; k++)
39
    {
40
      tep = que.front();
41
      si = tep.index[k];
42
      dnum = (si % 7 == 0) ? si / 7 * 10 + 12 : tep.a[si - 1] + 1;
43
      if(dnum == 2 || dnum % 10 == 8)
44
      {
45
        continue;
46
      }
47
      for(i = 0; i < 28; i++)
48
      {
49
        if(tep.a[i] == dnum)
50
        {
51
          di = i;
52
          break;
53
        }
54
      }
55
      tep.a[di] = 1;
56
      tep.a[si] = dnum;
57
      tep.index[k] = di;
58
      tep.t++;
59
      if(strcmp(tep.a, end) == 0)
60
      {
61
        return tep.t;
62
      }
63
      if(mp.count(tep.a) == 1)
64
      {
65
        continue;
66
      }
67
      mp[tep.a] = true;
68
      que.push(tep);
69
    }
70
    que.pop();
71
  }
72
  return -1;
73
}
74

75
int main()
76
{
77
  int n, i, j, k, ans, in;
78
  node start;
79

80
  scanf("%d", &n);
81
  while(n--)
82
  {
83
    k = 0;
84
    for(i = 0; i < 4; i++)
85
    {
86
      for(j = 0; j < 7; j++)
87
      {
88
        scanf("%d", &in);
89
        start.a[i * 7 + j] = (char)in;
90
        if(start.a[i * 7 + j] % 10 == 1)
91
        {
92
          start.a[i * 7 + j] = 1;
93
          start.index[k] = i * 7 + j;
94
          k++;
95
        }
96
      }
97
    }
98
    start.a[28] = '\0';
99
    start.t = 0;
100
    ans = solve(start);
101
    printf("%d\n", ans);
102
  }
103
  return 0;
104
}

展开收起

数字图像基础

Tue, 18 Feb 2020 20:44:55 GMT

基本概念#

单色光：没有颜色的光，单色光的唯一属性是强度。

灰度级：单色光的强度，从黑到白的单色光的度量值范围。

灰度图像：用单色光来表示的图像。

一幅图像可以用一个矩阵来表示，矩阵中某个元素表示图像在该点的像素，可以是灰度值或RGB值等。

空间域：一幅数字图像的坐标张成的实平面部分。

像素：图像矩阵中的元素，也可以称之为图像单元或图像元素。

噪声：存在于图像数据中的不必要的或多余的干扰信息。

对比度：图像中最高和最低灰度级间的灰度差。

饱和度：指图像色彩的纯净程度。

空间分辨率：用来度量图像中可辨别的最小细节，，通常用单位距离的线对数或单位距离的点数（像素数）来衡量。

dpi：每英寸点数，通常作为单位距离点数的单位。

灰度分辨率：指灰度级中可分辨的最小变化，用于量化灰度的比特数。例如，通常说一幅被量化为256级的图像有8比特的灰度分辨率。

像素间的基本关系#

相邻像素#

4邻域：与像素相邻的四个水平和垂直的相邻像素，坐标为(x,y)(x,y)(x,y)的像素的4邻域坐标为(x+1,y),(x−1,y),(x,y+1),(x,y−1)(x+1,y), (x-1,y), (x,y+1), (x,y-1)(x+1,y),(x−1,y),(x,y+1),(x,y−1)，像素点p的4邻域可以用N4(p)N_4(p)N4(p)表示。

D邻域：与像素相邻的四个对角相邻像素，坐标为(x,y)(x,y)(x,y)的像素的D邻域坐标为(x−1,y−1),(x−1,y+1),(x+1,y−1),(x+1,y+1)(x-1,y-1), (x-1,y+1), (x+1,y-1), (x+1,y+1)(x−1,y−1),(x−1,y+1),(x+1,y−1),(x+1,y+1)，像素点p的4邻域可以用ND(p)N_D(p)ND(p)表示。

8邻域：由像素的4邻域和D邻域组成。像素点p的8邻域可以用N8(p)N_8(p)N8(p)表示。

位于图像边界的像素点的4邻域、D邻域和8邻域会落入图像的外部。

邻接性#

令VVV是定义邻接的灰度值集合，假设像素ppp和qqq的像素值在集合VVV中，像素ppp和qqq的4邻接、8邻接和m邻接定义如下

4邻接：如果qqq在ppp的4邻域中，则ppp和qqq是4邻接的。
8邻接：如果qqq在ppp的8邻域中，则ppp和qqq是8邻接的。
m邻接：如果像素ppp和qqq满足以下两个条件之一，则ppp和qqq是m邻接的。m邻接也叫混合邻接，m邻接是8邻接的改进，目的是消除8邻接带来的对角相邻像素之间可能产生的多余的斜向路径。
1. qqq在ppp的4邻域中。
2. qqq在ppp的D邻域中，且ppp和qqq的4邻域交集中没有没有来自VVV中数值的像素。

连通性#

通路：像素ppp到像素qqq之间的通路是由不同像素组成的一个序列，序列中左右相邻的两个像素之间都是邻接的。可根据不同的邻接类型（4邻接、8邻接、m邻接）定义不同的通路类型（4通路、8通路、m通路），其中8通路可能不唯一。

连通：令SSS是图像中的一个像素子集（图像中像素点组成的集合）。如果两个像素ppp和qqq之间存在一条完全由SSS中的像素构成的通路（像素ppp和qqq均在SSS中），那么称像素ppp和qqq在SSS中连通。

连通分量：对于SSS中的任意一个像素ppp，在SSS中与像素ppp连通的像素构成的像素集合称为SSS的连通分量。

连通集：如果SSS仅有一个连通分量，即SSS中的所有像素互相都连通，则SSS称为连通集。

区域和边界#

区域：令RRR是图像中的一个像素子集，如果RRR是一个连通集，则称RRR为图像的一个区域。

邻接区域：两个区域RiR_iRi和RjR_jRj，如果将他们合并后能够形成一个连通集，则称区域RiR_iRi和RjR_jRj为邻接区域。不邻接的区域称为不邻接区域。

边界：区域RRR的边界（也叫边框或者轮廓）是区域RRR中与RRR的补集邻接的像素点组成的集合。

假设一幅图像中含有KKK个不邻接的区域Rk,k=1,2,...,KR_k,k=1,2,...,KRk,k=1,2,...,K，且这些区域都不接触图像的边界。令RuRuRu表示这KKK个区域的并集，(Ru)c(Ru)c(Ru)c表示RuRuRu的补集，那么RuRuRu称中的所有像素点为图像的前景，(Ru)c(Ru)c(Ru)c中的所有像素点为图像的背景。

上述边界的定义有时称为区域的内边界，即边界像素是在区域内部。与内边界相区分的是外边界，即边界像素在背景区域内。

距离度量#

设像素点ppp的坐标为(xp,yp)(x_p,y_p)(xp,yp)，qqq的坐标为(xq,yq)(x_q,y_q)(xq,yq)，则ppp和qqq之间的三种距离定义如下。

欧式距离：用De(p,q)D_e(p,q)De(p,q)来表示。

De(p,q)=(xp−xq)2+(yp−yq)2D_e(p,q) = \sqrt{(x_p - x_q)^2 + (y_p - y_q)^2}De(p,q)=(xp−xq)2+(yp−yq)2

在欧式距离度量下，到像素点(x,y)(x,y)(x,y)的距离小于等于某一特定值rrr的像素都在以(x,y)(x,y)(x,y)为中心、半径为rrr的圆形区域内。

城市距离：用D4(p,q)D_4(p,q)D4(p,q)来表示。

D4(p,q)=∣xp−xq∣+∣yp−yq∣D_4(p,q) = |x_p - x_q| + |y_p - y_q|D4(p,q)=∣xp−xq∣+∣yp−yq∣

在城市距离度量下，到像素点(x,y)(x,y)(x,y)的距离小于等于某一特定值rrr的像素形成一个以(x,y)(x,y)(x,y)为中心的菱形区域。

棋盘距离：用D8(p,q)D_8(p,q)D8(p,q)来表示。

D8(p,q)=max(∣xp−xq∣,∣yp−yq∣)D_8(p,q) = max(|x_p - x_q|,|y_p - y_q|)D8(p,q)=max(∣xp−xq∣,∣yp−yq∣)

在棋盘距离度量下，到像素点(x,y)(x,y)(x,y)的距离小于等于某一特定值rrr的像素形成一个以(x,y)(x,y)(x,y)为中心的方形区域。

数学基础#

阵列与矩阵操作#

阵列操作：对图像矩阵中每个像素进行操作，比如对图像阵列进行求幂操作，表示对图像矩阵中每个像素都进行求幂。

矩阵操作：对图像矩阵进行矩阵的操作，矩阵的操作请参考线性代数里的介绍。

矩阵操作的乘法和阵列操作的乘法不同。

阵列操作的乘法：

[a11a12a21a22][b11b12b21b22]=[a11b11a12b12a21b21a22b22]\left[\begin{matrix} a_{11} & a_{12} \\ a_{21} & a_{22} \\ \end{matrix}\right] \left[\begin{matrix} b_{11} & b_{12} \\ b_{21} & b_{22} \\ \end{matrix}\right] = \left[\begin{matrix} a_{11}b_{11} & a_{12}b_{12} \\ a_{21}b_{21} & a_{22}b_{22} \\ \end{matrix}\right][a11a21a12a22][b11b21b12b22]=[a11b11a21b21a12b12a22b22]

矩阵操作的乘法：

[a11a12a21a22][b11b12b21b22]=[a11b11+a12b21a11b12+a12b22a21b11+a22b21a21b12+a22b22]\left[\begin{matrix} a_{11} & a_{12} \\ a_{21} & a_{22} \\ \end{matrix}\right] \left[\begin{matrix} b_{11} & b_{12} \\ b_{21} & b_{22} \\ \end{matrix}\right] = \left[\begin{matrix} a_{11}b_{11} + a_{12}b_{21} & a_{11}b_{12} + a_{12}b_{22} \\ a_{21}b_{11} + a_{22}b_{21} & a_{21}b_{12} + a_{22}b_{22} \\ \end{matrix}\right][a11a21a12a22][b11b21b12b22]=[a11b11+a12b21a21b11+a22b21a11b12+a12b22a21b12+a22b22]

线性操作#

图像处理方法最重要的分类依据之一是，它是线性的还是非线性的。考虑一般的算子HHH，该算子对于给定的输入图像f(x,y)f(x,y)f(x,y)，产生一幅输出图像g(x,y)g(x,y)g(x,y)：

H[f(x,y)]=g(x,y)H[f(x, y)] = g(x, y)H[f(x,y)]=g(x,y)

加性：对两个输入的和进行操作得到的输出，与分别对两个输入进行操作后的输出求和得到的结果相同，用公式可表示为：

H[fi(x,y)+fj(x,y)]=H[fi(x,y)]+H[fi(x,y)]H[f_i(x, y) + f_j(x, y)] = H[f_i(x, y)] + H[f_i(x, y)]H[fi(x,y)+fj(x,y)]=H[fi(x,y)]+H[fi(x,y)]

同质性：输入乘以一个常数的输出，与原始输入的输出再乘以该常数的结果相同，用公式可表示为：

H[a×f(x,y)]=a×H[f(x,y)]H[a \times f(x, y)] = a \times H[f(x, y)]H[a×f(x,y)]=a×H[f(x,y)]

线性操作：同时满足加性和同质性的操作，线性操作的算子成为线性算子，如果HHH是一个线性算子，则需要满足：

H[aifi(x,y)+ajfj(x,y)]=aiH[fi(x,y)]+ajH[fj(x,y)]=aigi(x,y)+ajgj(x,y)H[a_if_i(x, y) + a_jf_j(x, y)] = a_iH[f_i(x, y)] + a_jH[f_j(x, y)] = a_ig_i(x, y) + a_jg_j(x, y)H[aifi(x,y)+ajfj(x,y)]=aiH[fi(x,y)]+ajH[fj(x,y)]=aigi(x,y)+ajgj(x,y)

上式中，aia_iai和aja_jaj是任意常数，fi(x,y)f_i(x, y)fi(x,y)和fj(x,y)f_j(x, y)fj(x,y)是任意大小相同的图像。

算术操作#

图像间的算术操作是在相应的像素对之间执行的，属于阵列操作，4种算术操作（即像素间加减乘除）表示为：

s(x,y)=f(x,y)+g(x,y)d(x,y)=f(x,y)−g(x,y)p(x,y)=f(x,y)×g(x,y)v(x,y)=f(x,y)÷g(x,y)\begin{aligned} s(x, y) = f(x, y) + g(x, y) \\ d(x, y) = f(x, y) - g(x, y) \\ p(x, y) = f(x, y) \times g(x, y) \\ v(x, y) = f(x, y) \div g(x, y) \end{aligned}s(x,y)=f(x,y)+g(x,y)d(x,y)=f(x,y)−g(x,y)p(x,y)=f(x,y)×g(x,y)v(x,y)=f(x,y)÷g(x,y)

上式中fff和ggg是两张大小相同的图像，计算得到的sss、ddd、ppp和vvv也是和fff、ggg大小相同的图像。

图像相加后取平均值可以降低图像的噪声。在天文学邻域，由于在非常低的光照下成像常常会导致传感器噪声，以至于单幅图像无法分析。一种降低噪声的方法是对同一个区域（比如某个星系）进行长时间观测，采集多张图片，然后将这多张图像进行算术相加再取平均值，最后得到的图像相比于单张图像会清晰很多。

图像相减可以增强两幅近似图像之间的差别，比如观测某一区域的变化过程，可以用采集的图像与第一次采集的图像相减，以增强两幅图像变化比较明显的部分，降低变化比较小的部分。

图像相乘的一个重要应用是矫正阴影（这个没看懂T﹏T）。也用来进行模板操作。

空间操作#

空间操作直接在给定图像的像素上执行。

单像素操作#

单像素操作生成的图像，每个像素是根据原图中相应像素计算得到的。用公式表示是：

g(x,y)=T[f(x,y)]g(x, y) = T[f(x, y)]g(x,y)=T[f(x,y)]

f(x,y)f(x, y)f(x,y)表示原图在(x,y)(x, y)(x,y)处的像素，TTT表示像素的映射函数，g(x,y)g(x, y)g(x,y)表示生产图像对应位置的像素。

领域操作#

领域操作生成的图像，每个像素是根据原图中相应像素的领域计算得到的。用公式表示是：

g(x,y)=T[N(f(x,y))]g(x, y) = T[N(f(x, y))]g(x,y)=T[N(f(x,y))]

N(f(x,y))N(f(x, y))N(f(x,y))表示图像在(x,y)(x, y)(x,y)处的领域。

几何空间变换#

请参考我的另一篇博客图像的几何空间变换。

图像配准#

图像几何空间变换利用已知的变换函数，将原图像上的像素映射到目标图像上指定的位置。而图像的配准则是根据原图像和目标图像上某些像素点之间的映射关系，求变换函数。具体的做法是假设变换函数的模型，然后在原图像上取一些点，将这些点的坐标和它们映射在目标图像上对应点的坐标，代入变换函数模型中，求解出变换函数的未知参数，最终得到变换函数。

举个栗子，假设目标图像是原图像通过仿射变换生成的，变换方式如下：

根据这个变换函数可以列出以下两个方程，这个两个方程就是变换函数的模型。

x=t11v+t21w+t31y=t12v+t22w+t32\begin{aligned} x = t_{11}v + t_{21}w + t_{31} \\ y = t_{12}v + t_{22}w + t_{32} \end{aligned}x=t11v+t21w+t31y=t12v+t22w+t32

然后取原图像上的三个点(v1,w1)(v_1, w_1)(v1,w1)、(v2,w2)(v_2, w_2)(v2,w2)、(v3,w3)(v_3, w_3)(v3,w3)，假设它们在目标图像上对应点的坐标分别是(x1,y1)(x_1, y_1)(x1,y1)、(x2,y2)(x_2, y_2)(x2,y2)、(x3,y3)(x_3, y_3)(x3,y3)，将这六个点的坐标值代入变换函数模型中，可以的到两个三元一次方程组：

{x1=t11v1+t21w1+t31x2=t11v2+t21w2+t31x3=t11v3+t21w3+t31 {y1=t12v1+t22w1+t32y2=t12v2+t22w2+t32y3=t12v3+t22w3+t32\begin{cases} x_1 = t_{11}v_1 + t_{21}w_1 + t_{31} \\ x_2 = t_{11}v_2 + t_{21}w_2 + t_{31} \\ x_3 = t_{11}v_3 + t_{21}w_3 + t_{31} \end{cases} \ \ \ \ \ \ \ \begin{cases} y_1 = t_{12}v_1 + t_{22}w_1 + t_{32} \\ y_2 = t_{12}v_2 + t_{22}w_2 + t_{32} \\ y_3 = t_{12}v_3 + t_{22}w_3 + t_{32} \end{cases}⎩⎨⎧x1=t11v1+t21w1+t31x2=t11v2+t21w2+t31x3=t11v3+t21w3+t31 ⎩⎨⎧y1=t12v1+t22w1+t32y2=t12v2+t22w2+t32y3=t12v3+t22w3+t32

解出这两个方程组就可以算出t11,t12,t21,t22,t31,t32t_{11}, t_{12}, t_{21}, t_{22}, t_{31}, t_{32}t11,t12,t21,t22,t31,t32这几个参数，代入模型中就是我们要求的变换函数了。

HDU-3085 Nightmare Ⅱ

Sat, 15 Feb 2020 16:57:20 GMT

题目#

地址：http://acm.hdu.edu.cn/showproblem.php?pid=3085

题意#

给出一个n×m的迷宫，迷宫里有些地方是墙，有些地方是空地，迷宫里还有两只鬼，鬼可以分身，以每秒两步的速度向附近扩散，而且鬼可以穿墙。erriyue和他的女朋友在迷宫里面，erriyue每秒钟可以走3步，他的女朋友每秒钟可以走一步。问erriyue能否在在鬼抓到他或他女朋友之前，与他女朋友会合，如果可以输出最少需要的时间，否则输出-1。

墙用#表示
空地用.表示
鬼的初始位置用M表示
erriyue的初始位置用M表示
erriyue的女朋友初始位置用G表示

解题思路#

以erriyue和他女朋友为原点，使用双向广度优先搜索路径，同时使用曼哈顿距离（也就是两个方向上的距离和）来判断会不会被鬼追上。双向的广度优先搜索相当单向的耗时少一点，用曼哈顿距离就可以不用把鬼加到队列里了，省了空间。

代码#

1
#include <stdio.h>
2
#include <string.h>
3
#include <queue>
4

5
using namespace std;
6

7
const int MAX_N = 800 + 10;
8
// const int MAX_N = 2 + 10;
9

10
typedef struct point
11
{
12
  int x, y;
13
} point;
14

15
int n, m;
16
char mp[MAX_N][MAX_N];
17
char book[2][MAX_N][MAX_N];
18
queue<point> que[2];
19
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
20

21
int abs(int a, int b)
22
{
23
  return (a > b) ? a - b : b - a;
24
}
25

26
int check_point(point p, point zs[], int t)
27
{
28
  if (abs(p.x, zs[0].x) + abs(p.y, zs[0].y) <= 2 * t ||
29
    abs(p.x, zs[1].x) + abs(p.y, zs[1].y) <= 2 * t)
30
  {
31
    return 1;
32
  }
33
  return 0;
34
}
35

36
int step_one(int mg, point zs[], int t)
37
{
38
  int i, pn;
39
  point front, tep;
40

41
  pn = que[mg].size();
42
  while(pn--)
43
  {
44
    front = que[mg].front();
45
    que[mg].pop();
46
    if(check_point(front, zs, t))
47
    {
48
      continue;
49
    }
50
    for(i = 0; i < 4; i++)
51
    {
52
      tep = front;
53
      tep.x += dir[i][0];
54
      tep.y += dir[i][1];
55
      if(tep.x < 0 || tep.x >= n || tep.y < 0 || tep.y >= m)
56
      {
57
        continue;
58
      }
59
      if(check_point(tep, zs, t) || mp[tep.x][tep.y] == 'X' || book[mg][tep.x][tep.y] == 1)
60
      {
61
        continue;
62
      }
63
      if(book[!mg][tep.x][tep.y] == 1)
64
      {
65
        return 1;
66
      }
67
      book[mg][tep.x][tep.y] = 1;
68
      que[mg].push(tep);
69
    }
70
  }
71
  return 0;
72
}
73

74
int solve(point ms, point gs, point zs[])
75
{
76
  int t;
77

78
  memset(book, 0, sizeof(book));
79
  book[0][ms.x][ms.y] = 1;
80
  book[1][gs.x][gs.y] = 1;
81
  que[0].push(ms);
82
  que[1].push(gs);
83
  t = 0;
84
  while(que[0].empty() == false || que[1].empty() == false)
85
  {
86
    t++;
87
    if(step_one(0, zs, t) == 1) return t;
88
    if(step_one(0, zs, t) == 1) return t;
89
    if(step_one(0, zs, t) == 1) return t;
90
    if(step_one(1, zs, t) == 1) return t;
91
  }
92
  return -1;
93
}
94

95
int main()
96
{
97
  int t, i, j, k, ans;
98
  point ms, gs, zs[2];
99

100
  scanf("%d", &t);
101
  while(t--)
102
  {
103
    scanf("%d %d", &n, &m);
104
    getchar();
105
    k = 0;
106
    for(i = 0; i < n; i++)
107
    {
108
      scanf("%s", mp[i]);
109
      for(j = 0; j < m; j++)
110
      {
111
        if(mp[i][j] == 'M')
112
        {
113
          ms = (point){i, j};
114
        }
115
        else if(mp[i][j] == 'G')
116
        {
117
          gs = (point){i, j};
118
        }
119
        else if(mp[i][j] == 'Z')
120
        {
121
          zs[k] = (point){i, j};
122
          k++;
123
        }
124
      }
125
    }
126

127
    while(que[0].empty() == false) que[0].pop();
128
    while(que[1].empty() == false) que[1].pop();
129
    ans = solve(ms, gs, zs);
130
    printf("%d\n", ans);
131
  }
132
  return 0;
133
}

展开收起

Markdown语法教程

Fri, 07 Feb 2020 13:00:05 GMT

写在前面#

前两天用Gridea和Github Pages搭好了我的博客，不得不说，这两个都是好东西，而且都是免费的。Gridea用来搭建个人博客容易，而且人性化，适合像我这样的菜鸟上手，Github Pages提供平台展示博客。在这里感谢一下Gridea和Github Pages的开发者们。

Gridea支持Markdown语法，我这个菜鸟又不会，所以打算学一下，顺便写一篇介绍基本语法的博文，作为我的第一篇博文，下面进入正题吧！

Markdown简介#

Markdown 语言由约翰·格鲁伯(John Gruber)于2004年创建，是一种轻量级标记语言。Markdown允许人们使用易读易写的纯文本来编写带样式的文档，有点类似html，不过它比html简单一些。Markdown 编写的文档可以导出 HTML 、Word、图像、PDF、Epub 等多种格式的文档。使用Markdown 编写的文档后缀为 .md, .markdown，比如github仓库里的README.md文档。

关于Markdown的编辑器，可分为以下三类：

平台集成工具：各大在线博客、社区平台自带的写作工具，比如CSDN、博客园、简书等。
独立软件类：在本地上使用的独立软件，可以编辑本地文件，比如Typora、Haroopad等。
插件类：有些编辑器安装相应的插件，可以具有Markdown的功能，比如Atom、VS code、Sublime Text等。

标题#

标题可以使用两种方式来设置，一种是用“=”和“-”，一种是用“#”。

使用“=”和“-”符号，在标题的下一行加一个“=”，就会有一级标题的效果，如果加“-”的话就是二级标题。
```
1
一级标题
2
=
3
二级标题
4
-
```
效果如下：

需要注意的是，使用这种方式的标题，上一行如果是普通文本，两行之间要加一个换行，不然上一行文本也会有标题的样式。
使用“#”符号，在标题的前面加“#”符号就好了，加几个“#”就代表几级标题，最多支持6级标题。
```
1
# 一级标题
2
## 二级标题
3
### 三级标题
4
#### 四级标题
5
##### 五级标题
6
###### 六级标题
```
效果如下：

字体#

简单字体#

Markdown 可以使用以下几种字体：

1
*斜体文本*
2
_斜体文本_
3
**粗体文本**
4
__粗体文本__
5
***粗斜体文本***
6
___粗斜体文本___
7
<u>带下划线文本</u>
8
~~带删除线文本~~

效果如下：

斜体文本

粗体文本

粗斜体文本

带下划线文本

带删除线文本

自定义字体#

Markdown的最初目标就是为纯写作而生的，因此，它并没有考虑文字的更多样式。如果想使用更多字体样式，可以借助html的font标签。

1
<font color=red>红色字体</font>
2
<font size=6>6号字体</font>
3
<font color=red size=6>6号红色字体</font>

效果如下：

红色字体

6号字体

6号红色字体

空格#

Markdown不能直接用键盘输入的空格和回车来表示空格，需要用特殊符号。

&ensp;或 表示半角空格(En Space)，占一个字符，相当于半个汉字的长度。

&emsp;或 表示全角空格(Em Space)，占两个字符，相当于一个汉字的长度。

 或 不换行空格(No-Break Space)，占一个字符，相当于一个字符”n”的长度。

半角空格和全角空格推荐在中文里使用，不换行空格推荐在英文里使用。

换行#

markdown里敲多个换行只能显示一个，如果想显示多个换行，需要用<br>或者<br/>来表示。

引用#

引用的文字段落会高亮显示，方法是在文字开头加”>“符号。

1
> 最外层
2
>> 第一层嵌套
3
>>> 第二层嵌套

最外层
第一层嵌套
第二层嵌套

图片#

简单图片#

如果是想简单的显示图片，使用以下方式就好了：

1
![](图片地址)

图片链接地址可以是本地图片文件地址，也可以是网络图片地址。

也可以给图片添加说明和标题：

1
![图片说明文字](图片链接地址 "图片标题")

图片说明文字会在图片无法加载时显示，图片正常加载时说明文字不显示，下面是一个例子。

1
![这是一张无法加载的图片](错误的图片地址 "title")

显示为

如果图片有标题，当鼠标停在图片上时会显示出来，即使图片无法加载，鼠标停靠时也会显示，下面是一个例子，请读者自行尝试。

1
![涅普迪努](./nepnep.png "我可爱吗^_^")

涅普迪努

自定义图片#

Markdown无法自定义图片的宽度和高度，如果想改变的话需要借助html的img标签。

1
<img width=100 height=160 src="./nepnep.png" title="我是变小后的涅普迪努"></img>

下面是一张100×160的图片

链接#

外部链接#

markdown可以使用两种方法创建链接

1
[链接名称](链接地址)
2
<链接地址>

以github主页为例：

1
[github](https://github.com)
2
<https://github.com>

效果如下：

github https://github.com

内部链接#

可以使用内部链接跳转到本文内某个标题的位置，语法如下：

1
[链接名字][#标题名字]

比如想跳转转到本文的“Markdown简介”的位置，可以用下面的代码实现：

1
[Markdown简介](#Markdown简介)

Markdown简介

列表#

无序列表#

无序列表使用星号(*)、加号(+)或是减号(-)作为列表标记：

1
* 第一项
2
* 第二项
3
* 第三项
4

5
+ 第一项
6
+ 第二项
7
+ 第三项
8

9
- 第一项
10
- 第二项
11
- 第三项

第一项
第二项
第三项

第一项
第二项
第三项

第一项
第二项
第三项

有序列表#

有序列表使用数字并加上 . 号来表示，如：

1
1. 第一项
2
2. 第二项
3
3. 第三项

第一项
第二项
第三项

markdown会对数字重新按顺序编号，比如下面代码显示的编号任然是1.2.3.

1
1. 第一项
2
1. 第二项
3
237. 第三项

第一项
第二项
第三项

嵌套列表#

列表嵌套只需在子列表中的选项添加四个空格即可：

1
1. 第一项：
2
    - 第一项嵌套的第一个元素
3
    - 第一项嵌套的第二个元素
4
2. 第二项：
5
    - 第二项嵌套的第一个元素
6
    - 第二项嵌套的第二个元素

第一项：
- 第一项嵌套的第一个元素
- 第一项嵌套的第二个元素
第二项：
- 第二项嵌套的第一个元素
- 第二项嵌套的第二个元素

表格#

Markdown 制作表格使用 | 来分隔不同的单元格，使用 - 来分隔表头和其他行。语法格式如下：

1
|  表头   | 表头  |
2
|  ----  | ----  |
3
| 单元格  | 单元格 |
4
| 单元格  | 单元格 |

显示效果：

表头	表头
单元格	单元格
单元格	单元格

设置表格的对齐方式：

-: 设置内容和标题栏居右对齐。
:- 设置内容和标题栏居左对齐。
:-: 设置内容和标题栏居中对齐。

实例如下：

1
| 左对齐的一列 | 右对齐的一列 | 居中对齐的一列 |
2
| :----| ----: | :----: |
3
| 单元格 | 单元格 | 单元格 |
4
| 单元格 | 单元格 | 单元格 |

显示效果：

左对齐的一列	右对齐的一列	居中对齐的一列
单元格	单元格	单元格
单元格	单元格	单元格

代码#

代码片段#

代码片段可以用一个或两个反引号”`“包起来，比如：

1
c语言常用`scanf()`和``printf()``函数来输入输出。

显示为：c语言常用scanf()和printf()函数来输入输出。

代码段落#

代码段落可以用三个反引号”```“或三个”~~~“来显示(三个以上也可以)，比如：

1
```
2
#include <stdio.h>
3

4
int main(int argc, int argv[])
5
{
6
    printf("hello world!\n");
7
    return 0;
8
}
9
```

显示为：

1
#include <stdio.h>
2

3
int main(int argc, int argv[])
4
{
5
    printf("hello world!\n");
6
    return 0;
7
}

在前面的三个反引号后面加入编程语言的关键字，还可以显示语法高亮，比如：

1
```python
2
import numpy as np
3

4
def sigmoid(self, input):
5
    return 1.0 / (1.0 + np.exp(-input))
6
```

显示为：

1
import numpy as np
2

3
def sigmoid(self, input):
4
    return 1.0 / (1.0 + np.exp(-input))

以下为常用的语言的语法关键字

语言	关键字
C	cpp, c
Java	java
Python	py, python
Shell	bash, shell
C#	csharp, c#
CSS	css
JavaScript	js, jscript, javascript
XML	xml , xhtml, xslt, html
PHP	php
SQL	sql

转义字符#

markdown里有些字符代表特殊功能，比如 * 代表无序列表开始标志，如果只是想显示这些符号，而不使用符号的特殊功能，需要在符号前加一个 \ ，markdown里需要转义的字符如下：

	原始字符	显示效果
反斜杠	\\	\
反引号	\`	`
星号	\*	*
井号	\#	#
加号	\+	+
减号	\-	-
点	\.	.
感叹号	\!	!
大括号	\{\}	{}
中括号	\[\]	[]
小括号		()

其他#

目录#

部分markdown平台支持目录自动生成，比如gridea可以用@[TOC]来插入目录，Typora用[TOC]插入目录。如果平台不支持的话，可以使用mardown的编辑器来生成，或者使用上面提到的列表和内部链接自己做一个，当然这样比较麻烦，而且无法与标题自动同步。

脚注#

markdown支持添加脚注，点击脚注后，会跳转到文档的底部的说明位置，语法如下：

1
[^关键字]
2
[^关键字]: 脚注说明内容

第一行代码添加了一个脚注，第二行代码对脚注进行了定义，如果对添加的脚注不进行定义的话，脚注无法显示。markdown在显示脚注的时候会按照顺序进行编号，下面是一个例子。

1
文本[^第一个脚注]
2
[^第一个脚注]: 这里是第一个脚注的说明。
3

4
文本[^第二脚注]
5
[^第二脚注]: 这里是第二个脚注的说明。

显示结果：

文本¹

文本²

分割线#

markdown可以在一行上连用三个或者三个以上的星号、减号、或者下划线来表示分割线。

1
***
2
---
3
___

显示效果：

数学公式#

可以参考这个大佬的链接http://blog.lisp4fun.com/2017/11/01/formula

Footnotes#

这里是第一个脚注的说明。 ↩
这里是第二个脚注的说明。 ↩