$\mathcal{2023WinterHoliday}$刷题总结

\(\mathcal{2023WinterHoliday}\)

\(\mathcal{CTF}\)

\(\mathcal{web}\)

1.\(json格式：\)$json['x']=="wllm"

\(JSON\)（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式，采用完全独立于编程语言的文本格式来存储和表示数据。

JSON的值:

1. JSON的构成: $ws $值
2. 值可以是对象、数组、数字、字符串或者三个字面值(false、null、true)中的一个。值中的字面值中的英文必须使用小写。
3. 对象由花括号括起来的逗号分割的成员构成，成员是字符串键和上文所述的值由逗号分割的键值对组成，如：

{"name": "John Doe", "age": 18, "address": {"country" : "china", "zip-code": "10000"}}

引用\(JSON\)中的对象可以包含多个键值对，并且有数组结构，该语言正是一次实现过程内容的描述。

3.1 数组是由方括号括起来的一组值构成，如：

[3, 1, 4, 1, 5, 9, 2, 6]

3.2 字符串与C或者Java的字符串非常相似。字符串是由双引号包围的任意数量Unicode字符的集合，使用反斜线转义。一个字符（character）即一个单独的字符串（character string）。

3.3 数字也与C或者Java的数值非常相似。除去未曾使用的八进制与十六进制格式。除去一些编码细节。

2.\(php伪协议\)---多见于文件包含题中

常见伪协议	使用
\(file://\)	访问本地文件系统
\(php://\)	访问php各个输入输出的数据流\((i/o\,\,streams)\)
\(phar://\)	\(php\)归档（也不知道是个啥
\(zip://\)	压缩流,，类似的有bzip2://&zlib://协议
\(http://\)	常规\(url\)形式，允许通过\(http1.0\)的\(GET\)方法，以只读访问文件或资源。
\(data://\)	数据流封装器，以传递相应格式的数据，也是\(base64\)传输

1）\(php://filter\)是对内存or源代码进行读写的固定样式。

\(php://input\)用于php的代码执行

?a=php://filter/read=convert.base64-encode/resource=whoami

resource=<要过滤的数据流> 这个参数是必须的。它指定了你要筛选过滤的数据流

read=<读链的筛选列表> 该参数可选。可以设定一个或多个过滤器名称，以管道符（|）分隔。

2）\(data://text/plain\)（暂时只遇到了这个，会补充

?file=data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b
or
?file=data://text/plain;<?php phpinfo()?>//此处写传入内容

3.\(php\)文件上传的可用后缀

\(php3，php5，pht，phtml，phps\)都是\(php\)文件可运行的文件扩展名

4.\(.htaccess\)文件

\(.htaccess\)是个配置文件，里面写了一些可以被服务器软件检测执行的玩意，只要你往里面塞配置（规则），就可以在服务器里面蹦迪）利用这个可以绕过php文件上传限制

5.在\(php\)中能够造成文件包含的函数有include、require、include_once、require_once、highlight_file、show_source、file_get_contents、fopen、file、readfile

\(ACM\)

一周写了一道题可海星）链接NOIP提高组_2013

一次游戏可以分为两个过程 —— 将空白格子移动到目标棋子的周围，将空白格子和目标棋子一起移动。显然，第二个过程中，每一步都是先将空白格子和目标格子交换，再将空白格子移动到目标格子的另一个相邻位置，下一步继续交换。

预处理出 $ f(i, j, a, b) $ 表示当目标棋子在 $ (i, j) $，空白格子在它的 $ a $ 相邻方向上，（保持目标棋子不动）将空白格子移动到 $ b $ 相邻方向上，所需的最小代价。

对于一次游戏，首先枚举将空白格子移动到目标棋子的哪个方向上，之后循环进行以下两个操作：

1. 交换空白格子和目标棋子；
2. 将空白格子移动到目标棋子的另一个相邻方向上。

我们可以用 $ (i, j, k) $ 描述一个状态 —— 目标棋子在 $ (i, j) $ 上，空白格子在它的 $ k $ 相邻方向上。结合预处理出的 $ f(i, j, a, b) $，在状态图上求最短路即可。

注意起点与终点相同的特判。

#include <cstdio>
#include <climits>
#include <algorithm>
#include <queue>

const int MAXN = 30;
const int MAXQ = 500;
const int di[] = { 1, 0, 0, -1 };
const int dj[] = { 0, 1, -1, 0 };

int n, m;

struct Node {
    bool invalid;
    int cost[4][4];
    int dist;    // BFS prepare
    struct {
        int dist;
        bool inq;
    } v[4];      // SPFA
} map[MAXN + 1][MAXN + 1];

struct Point {
    int i, j;

    Point() {}
    Point(int i, int j) : i(i), j(j) {}

    Point move(int x) {
        return Point(i + di[x], j + dj[x]);
    }

    Node *operator->() const {
        return &map[i][j];
    }

    bool valid() const {
        return i > 0 && j > 0 && i <= n && j <= m;
    }

    bool operator==(const Point &other) const {
        return i == other.i && j == other.j;
    }
};

struct Status {
    Point p;
    int d;

    Status(Point p, int d) : p(p), d(d) {}
};

inline int bfs(Point s, Point t, Point p) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            map[i][j].dist = INT_MAX;
        }
    }

    std::queue<Point> q;
    s->dist = 0;
    q.push(s);

    while (!q.empty()) {
        Point v = q.front();
        q.pop();

        if (v == t) return v->dist;

        for (int i = 0; i < 4; i++) {
            Point u = v.move(i);

            if (u->invalid || u == p) continue;

            if (u->dist > v->dist + 1) {
                u->dist = v->dist + 1;
                q.push(u);
            }
        }
    }

    return INT_MAX;
}

inline void prepare() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (map[i][j].invalid) continue;

            Point v(i, j);
            for (int s = 0; s < 4; s++) {
                Point ps = v.move(s);

                for (int t = s + 1; t < 4; t++) {
                    Point pt = v.move(t);

                    if (!ps.valid() || ps->invalid || !pt.valid() || pt->invalid) v->cost[s][t] = v->cost[t][s] = INT_MAX;
                    else v->cost[s][t] = v->cost[t][s] = bfs(ps, pt, v);

#ifdef DBG
                    printf("[%d, %d] %d => %d = %d\n", v.i, v.j, s, t, v->cost[s][t]);
#endif
                }
            }
        }
    }
}

inline int spfa(Status s, Point t) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for (int k = 0; k < 4; k++) {
                map[i][j].v[k].dist = INT_MAX;
                map[i][j].v[k].inq = false;
            }
        }
    }

    std::queue<Status> q;
    q.push(s);
    s.p->v[s.d].dist = 0;

    while (!q.empty()) {
        Status status = q.front();
        q.pop();

        Point &v = status.p;
        int &d = status.d;

        v->v[d].inq = false;

        // Move the empty block
        for (int i = 0; i < 4; i++) {
            if (i == d || v->cost[d][i] == INT_MAX) continue;

            if (v->v[i].dist > v->v[d].dist + v->cost[d][i]) {
                v->v[i].dist = v->v[d].dist + v->cost[d][i];
#ifdef DBG
                printf("[%d, %d]->v[%d]->dist = %d\n", v.i, v.j, i, v->v[i].dist);
#endif
                if (!v->v[i].inq) {
                    v->v[i].inq = true;
                    q.push(Status(v, i));
                }
            }
        }

        // Swap
        if (v->v[d].dist != INT_MAX) {
            Point u = v.move(d);
            int t = 3 - d;
            if (u->v[t].dist > v->v[d].dist + 1) {
                u->v[t].dist = v->v[d].dist + 1;
                if (!u->v[t].inq) {
                    u->v[t].inq = true;
                    q.push(Status(u, t));
                }
            }
        }
    }

    int res = INT_MAX;
    for (int i = 0; i < 4; i++) {
        res = std::min(res, t->v[i].dist);
    }

    return res;
}

int main() {
    int q;
    scanf("%d %d %d", &n, &m, &q);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            int x;
            scanf("%d", &x);
            map[i][j].invalid = (x == 0);
        }
    }

    prepare();

    while (q--) {
        Point empty, s, t;
        scanf("%d %d %d %d %d %d", &empty.i, &empty.j, &s.i, &s.j, &t.i, &t.j);

        if (s == t) {
            puts("0");
            continue;
        }

        int ans = INT_MAX;
        for (int i = 0; i < 4; i++) {
            Point v = s.move(i);
            if (!v.valid()) continue;

            int d1 = bfs(empty, v, s);
            if (d1 == INT_MAX) continue;

            int d2 = spfa(Status(s, i), t);
            if (d2 == INT_MAX) continue;

            ans = std::min(ans, d1 + d2);
        }

        printf("%d\n", ans == INT_MAX ? -1 : ans);
    }

    return 0;
}

\(SRC\)

摆烂了一周））Web太烂了等我补一补先QAQ