
![image.png](/static/img/a47ce4968894dc8a45b44a7b914600ee.image.webp)

还是vscode用着顺手，自由度更高，可惜写Java必须得用IDEA,害

CRUD还是无聊,感觉还是Go方便，没那么多黑盒，可能是因为框架轻量？

写的时候能控制的地方很多，Spring就不是，我嘞个都，但是Spring有兜底，模板式的代码就那好处



![image.png](/static/img/388abf258b10ea4b466aa01eeb317751.image.webp)

Go的swagger是这样的，感觉挺方便，而且都能一键生成


![image.png](/static/img/e80106949430ab63b107fba1bfb9b93e.image.webp)
![image.png](/static/img/3123f53173289bbf6e1e30a573533daf.image.webp)


比注解好多了，清晰

但是注解方便

好好学好好练，希望能把用到的都学透！打算前端换React

编码记录9.23

# 时间关系
### が早いか
「が早いか」是一个日语表达方式，用来表示“刚一...就...”或“一...就立刻...”。它用于描述两个动作或事件几乎同时发生，强调时间上的紧密相连和迅速的连续性。通常用于叙述两个动作的迅速交替或连续发生。


接续方式：
「動詞未然形」 + 「が早いか」

例句从简单到复杂：

1. 彼は家に着くが早いか、すぐに寝てしまった。
   （他一到家就立刻睡着了。）

2. 雨が降り出すが早いか、人々は急いで家に帰った。
   （雨刚一落下，人们就急忙回家了。）

3. ランプが消えるが早いか、部屋は真っ暗になった。
   （灯一熄灭，房间立刻变得漆黑。）

4. 話が終わるが早いか、彼は席を立って外に出た。
   （话音刚落，他就起身离开了房间。）

5. 電車が駅に着くが早いか、乗客たちは一斉にドアに向かって走り出した。
   （电车一到站，乘客们就立刻纷纷跑向车门。）

「が早いか」强调的是两个动作之间几乎没有时间差，通常用来描绘一种紧迫或迅速的场景。在使用时，它能够有效地传达出事件发生的连续性和动作的迅速性。

### 〜や/〜や否や
「〜や」以及「〜や否や」是日语中用来表示“刚一...就...”或“一...就立刻...”的表达方式。它们用于描述两个动作几乎同时发生，强调时间上的紧密相连。其中「〜や否や」的语气更为强烈，更明确地表示动作的连续性和迅速性。

接续方式：
1. 「動詞辞書形」 + 「や」
2. 「動詞辞書形」 + 「や否や」

例句从简单到复杂：

1. 彼は目を覚ますや、すぐに起き上がった。
    （他一醒来就立刻起床了。）

2. 電話が鳴るや、彼女は急いで部屋から飛び出した。
    （电话一响，她就急忙从房间跑出去了。）

3. 彼が話すや否や、みんなが一斉に笑い出した。
    （他一说完，大家就立刻都笑了起来。）

4. 雨が降り出すや否や、人々は慌てて家に帰った。
    （雨刚一落下，人们就急忙回家了。）

5. ドアが開くや否や、子供たちは外に駆け出していった。
    （门刚一打开，孩子们就立刻跑出去了。）

「〜や」和「〜や否や」都用于强调两个动作之间几乎没有时间差，通常用来描绘一种紧迫或迅速的场景。在使用时，它们能够有效地传达出事件发生的连续性和动作的迅速性。需要注意的是，「〜や否や」的使用略显古风，现代日语中「〜や」更为常见。


### 〜なり
「〜なり」是一个日语语法结构，用来表示“刚一...就...”或“一...就立刻...”。它用于描述两个动作或状态几乎同时发生，强调时间上的紧密相连。这个结构通常用于叙述一个动作发生后，紧接着另一个动作或反应立即发生的情况。

接续方式：
「動詞連用形」 + 「なり」

例句从简单到复杂：

1. 彼が部屋に入るなり、すぐに電話をかけ始めた。
    （他一进房间就立刻开始打电话。）

2. 雨が降り出すなり、人々は走って家に帰った。
    （雨刚一落下，人们就跑着回家了。）

3. 彼女は私の名前を呼ぶなり、泣き出してしまった。
    （她一叫我的名字就立刻哭了起来。）

4. その言葉を聞くなり、彼は顔色を変えた。
    （他一听那句话就立刻变了脸色。）

5. ランプが消えるなり、部屋は真っ暗になった。
    （灯一熄灭，房间立刻变得漆黑。）

「〜なり」强调的是两个动作之间几乎没有时间差，通常用来描绘一种紧迫或迅速的场景。在使用时，它能够有效地传达出事件发生的连续性和动作的迅速性。需要注意的是，「〜なり」有时也可以表示“就像...一样”的意思，但在这里我们关注的是表示时间上连续发生的用法。

### 〜そばから
「〜そばから」是一个日语表达方式，用来表示“刚一...就...”或“一边...一边...”。它用于描述一个动作刚刚发生，紧接着另一个动作或情况就发生了，强调两个动作的连续性和几乎同时发生的特点。这个表达通常带有“一边做某事一边就发生了另一件事”的含义，有时也带有“徒劳无功”的意味，因为前一个动作似乎没有产生预期的效果。

接续方式：
「動詞連用形」 + 「そばから」

例句从简单到复杂：

1. 彼は掃除をしたそばから、またすぐに部屋が散らかってしまった。
    （他刚打扫完房间，房间就又立刻变得乱七八糟了。）

2. 彼女は本を読むそばから、すぐに眠くなってしまう。
    （她一读书就立刻感到困倦。）

3. 私が話したそばから、彼は忘れてしまったようだ。
    （我刚说完，他就似乎已经忘记了。）

4. 彼は謝ったそばから、また同じ過ちを繰り返した。
    （他刚道完歉，就又犯了同样的错误。）

5. 私が料理を作ったそばから、子供たちが食べ始め、すぐに空になった。
    （我刚做好饭，孩子们就开始吃，一下子就吃光了。）

「〜そばから」强调的是动作的连续性和迅速性，以及有时候动作的徒劳感。在使用时，它能够有效地传达出事件发生的连续性和动作的迅速性，以及可能的无用功。


### 〜てからというもの（は）
「〜てからというもの（は）」是一个日语表达方式，用来表示“自从...之后”或“从...以来”。它用于强调某个特定事件或动作发生之后，情况或状态发生了变化，或者某个行为或事件成为了一个转折点，之后一直持续着某种新的状态或情况。

接续方式：
「動詞て形」 + 「からというもの（は）」

例句从简单到复杂：

1. 彼と別れたてからというもの、彼のことを考える日々が続いている。
    （自从和他分手以来，我一直在想着他。）

2. この町に引っ越してからというもの、毎日が新鮮で楽しい。
    （自从搬到这个城镇以来，每天都很新鲜和快乐。）

3. 彼女が会社を辞めてからというもの、連絡が全く取れなくなった。
    （自从她辞去公司工作以来，就完全联系不上她了。）

4. あの事件が起こってからというもの、町の雰囲気が一変した。
    （自从那个事件发生以来，城镇的氛围完全改变了。）

5. 退職してからというもの、時間に余裕ができて、趣味に没頭できるようになった。
    （自从退休以来，时间变得充裕了，可以专心于我的爱好了。）

「〜てからというもの（は）」强调的是从某个特定的过去事件或动作发生之后，情况发生了变化，并且这种变化一直持续到现在。在使用时，它能够有效地传达出时间上的连续性和事件对后续情况的影响。

### 〜にあって
「〜にあって」是一个日语表达方式，用来表示“在...的情况下”或“在...之中”。它用于描述在特定的环境、状况、时期或位置下，某个动作或状态发生或存在。这个表达强调的是在某个特定的背景或条件下，事情是如何进行或存在的。

接续方式：
「名詞」 + 「にあって」

例句从简单到复杂：

1. この困難な状況にあって、私たちは力を合わせて乗り越えなければならない。
    （在这个困难的情况下，我们必须齐心协力克服难关。）

2. 彼は若き日にあって、多くの冒険を経験した。
    （在他年轻的时候，他经历了很多冒险。）

3. 現代社会にあって、情報技術の進歩は目覚ましい。
    （在现代社会中，信息技术的进步是惊人的。）

4. 彼女は経済的に苦しい状況にあっても、決して諦めなかった。
    （即使在经济困难的情况下，她也从未放弃。）

5. この国が戦争にあって、多くの人々が苦しみを味わった。
    （在这个国家经历战争的时候，许多人尝到了苦难。）

「〜にあって」用于强调在特定的背景或条件下，事情是如何发生或存在的，它能够有效地传达出环境或条件对事件的影响和作用。

N1语法第一弹！

今天重温八皇后！可以是回溯题必做，算法小白头疼！https://www.luogu.com.cn/problem/P1219

这题是简化版！

```cpp
#include <iostream>
using namespace std;
const int MAXN = 13;
int n;
int queens[MAXN]; // queens[i] 表示第 i 行的棋子放在第 queens[i] 列
bool columns[MAXN], diag1[2 * MAXN - 1], diag2[2 * MAXN - 1];
int solutionCount = 0;
void printSolution() {
    for (int i = 0; i < n; ++i) {
        cout << queens[i] + 1 << " ";
    }
    cout << endl;
}
void solve(int row) {
    if (row == n) {
        // 找到一个解
        solutionCount++;
        if (solutionCount <= 3) {
            printSolution();
        }
        return;
    }
    for (int col = 0; col < n; ++col) {
        if (!columns[col] && !diag1[row + col] && !diag2[row - col + n - 1]) {
            // 放置棋子
            queens[row] = col;
            columns[col] = diag1[row + col] = diag2[row - col + n - 1] = true;
            // 递归下一行
            solve(row + 1);
            // 回溯
            columns[col] = diag1[row + col] = diag2[row - col + n - 1] = false;
        }
    }
}
int main() {
    cin >> n;
    // 初始化
    for (int i = 0; i < n; ++i) {
        columns[i] = false;
    }
    for (int i = 0; i < 2 * n - 1; ++i) {
        diag1[i] = diag2[i] = false;
    }
    // 从第 0 行开始搜索
    solve(0);
    // 输出解的总数
    cout << solutionCount << endl;
    return 0;
}
```

9.23算法题-重温八皇后！

2016.7阅读精读

今天做迷宫https://www.luogu.com.cn/problem/P1605


# 迷宫
## 题目描述
给定一个 $N \times M$ 方格的迷宫，迷宫里有 $T$ 处障碍，障碍处不可通过。
在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。
给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。
## 输入格式
第一行为三个正整数 $N,M,T$，分别表示迷宫的长宽和障碍总数。
第二行为四个正整数 $SX,SY,FX,FY$，$SX,SY$ 代表起点坐标，$FX,FY$ 代表终点坐标。
接下来 $T$ 行，每行两个正整数，表示障碍点的坐标。
## 输出格式
输出从起点坐标到终点坐标的方案总数。
## 样例 #1
### 样例输入 #1
```
2 2 1
1 1 2 2
1 2
```
### 样例输出 #1
```
1
```
## 提示
对于 $100\%$ 的数据，$1 \le N,M \le 5$，$1 \le T \le 10$，$1 \le SX,FX \le n$，$1 \le SY,FY \le m$。




```cpp
#include <iostream>
using namespace std;

const int MAXN = 5;
const int MAXM = 5;

int N, M, T;
int SX, SY, FX, FY;
bool maze[MAXN + 1][MAXM + 1]; // false 表示可以通过，true 表示障碍
bool visited[MAXN + 1][MAXM + 1]; // 记录是否访问过

int dx[] = {0, 0, 1, -1}; // 右、左、下、上
int dy[] = {1, -1, 0, 0};

int dfs(int x, int y) {
    if (x == FX && y == FY) {
        return 1; // 到达终点，返回1表示找到一条路径
    }

    visited[x][y] = true; // 标记当前位置为已访问
    int count = 0;

    for (int i = 0; i < 4; ++i) {
        int nx = x + dx[i];
        int ny = y + dy[i];

        if (nx >= 1 && nx <= N && ny >= 1 && ny <= M && !maze[nx][ny] && !visited[nx][ny]) {
            count += dfs(nx, ny); // 递归搜索下一个位置
        }
    }

    visited[x][y] = false; // 回溯，取消当前位置的访问标记
    return count;
}

int main() {
    cin >> N >> M >> T;
    cin >> SX >> SY >> FX >> FY;

    // 初始化迷宫
    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= M; ++j) {
            maze[i][j] = false;
            visited[i][j] = false;
        }
    }

    // 读取障碍点
    for (int i = 0; i < T; ++i) {
        int x, y;
        cin >> x >> y;
        maze[x][y] = true;
    }

    // 从起点开始DFS
    int result = dfs(SX, SY);

    cout << result << endl;

    return 0;
}
```

时间关系

が早いか

短篇1

迷宫