信行散记

ZROI-C-day1

2022-07-17T09:22:33.000Z

并查集

优化方式

路径压缩
按秩合并 (merge时size小的当儿子)

可撤销并查集

路径压缩是无法撤销的。
但按秩合并可以。
所以只写按秩合并就行。记一下 merge 的时候连的哪条边。
时间复杂度 $O(n \log n)$

template <const int N> struct dsu
{
    int f[N], g[N];
    stackint *, int>> s;
    void init(int n)
    {
        for (int i = 0; i <= n; i++)
            f[i] = i, g[i] = 1;
    }
    int get(int u)
    {
        return f[u] == u ? u : get(f[u]);
    }
    bool find(int u, int v)
    {
        return get(u) == get(v);
    }
    void merge(int u, int v)
    {
        u = get(u), v = get(v);
        if (u == v)
            return;
        if (g[u] > g[v])
            swap(u, v);
        s.push({f + u, f[u]}), f[u] = v;
        s.push({g + v, g[v]}), g[v] += g[u];
    }
    unsigned tag()
    {
        return s.size();
    }
    void undo(unsigned tag)
    {
        while (s.size() > tag)
            *s.top().first = s.top().second, s.pop();
    }
};

Kruskal 重构树

并查集在合并集合的时候是直接加一条边上去。
考虑另一种做法：找到 $u, v$ 所在树的根节点 $u', v'$ ，然后新建一个结点 $z$ 作为 $u', v'$ 的父亲。
这样我们就得到了 kruskal 重构树。
原树上的点在重构树上都是叶子结点，并且 kruskal 重构树是一棵二叉树。可以理解为一种特殊的三度化(树转二叉树)

错误合辑

2022-06-27T01:28:17.000Z

今天输出多组数据没有换行。
puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");puts("");putchar('\n')
尝试检查变量，交换变量
看清求什么
01背包倒着枚举，看清v,w
一定要看数据范围
dp的max,min要看好
~~看与标答相差几，找对应debug~~
下标从1开始！ ~~（特殊题除外)~~
多数据注意换行
无限扩展注意模坐标和原坐标
差分要开第二个数组(否则会出现奇奇怪怪的问题)
要bfs时看清数据范围，若超时，尝试双向bfs,但是可以用两个队列bfs，而不是压入两个~~差不多吧~~
单层图解决不了，试试多层图。
统计方案的时候答案一定要开 long long 啊啊啊啊啊啊.
long long f[N], g[N], ans

矩阵乘法相关

2022-06-26T10:32:52.000Z

矩阵乘法

乘 A, B 得 C

C 中的 $[i][j]$ = A 中的第 $i$ 行和 B 中的第 $j$ 列相乘 YYH

例题

AcWing 1303. 斐波那契前 n 项和
设

S_n = \sum_{i = 1}^{n} f_i \\F_n = \begin{bmatrix}f_n & f_{n + 1} &S_n\end{bmatrix} \\F_{n + 1} = \begin{bmatrix}f_{n + 1} & f_{n + 2} &S_{n + 1}\end{bmatrix}

然后设

F_i \times A = F_{i + 1}

于是我们有

F_n = F_1 \times A^{n - 1}

问题迎刃而解
但是, 怎么求A?

根据定义，我们需要 $A$ 中的每一列乘以对应的 $F$ 为下一个 $F$

于是

A = \begin{bmatrix}0 & 1 & 0 \\1 & 1 & 1 \\0 & 0 & 1\end{bmatrix}

#include 
#include 
#include 
#include 

using namespace std;

typedef long long LL;

const int N = 3;

int n, m;

void mul(int c[], int a[], int b[][N])
{
    int temp[N] = {0};
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
            temp[i] = (temp[i] + (LL)a[j] * b[j][i]) % m;

    memcpy(c, temp, sizeof temp);
}

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N] = {0};
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
            for (int k = 0; k < N; k ++ )
                temp[i][j] = (temp[i][j] + (LL)a[i][k] * b[k][j]) % m;

    memcpy(c, temp, sizeof temp);
}

int main()
{
    cin >> n >> m;

    int f1[N] = {1, 1, 1};
    int a[N][N] = {
        {0, 1, 0},
        {1, 1, 1},
        {0, 0, 1}
    };

    n -- ;
    while (n)
    {
        if (n & 1) mul(f1, f1, a);  // res = res * a
        mul(a, a, a);  // a = a * a
        n >>= 1;
    }

    cout << f1[2] << endl;

    return 0;
}

Congratulations!

再看

AcWing 1304. 佳佳的斐波那契

矩阵也很好求

设

T_n = \sum_{i = 1}^{n} i f_i \\F_n = \begin{bmatrix}f_n & f_{n + 1} &n f_n & (n+1) f_{n + 1} & T_n\end{bmatrix} \\F_{n + 1} = \begin{bmatrix}f_{n + 1} & f_{n + 2} & (n + 1) f_{n + 1} & (n + 2) f_{n + 2} & T_{n + 1}\end{bmatrix}

然后设

F_i \times A = F_{i + 1}

于是我们有

F_n = F_1 \times A^{n - 1}

A 怎么求？

#include 
#include 
#include 
#include 

using namespace std;

typedef long long LL;

const int N = 5;

int n, m;

void mul(int c[], int a[], int b[][N])
{
    int temp[N] = {0};
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
            temp[i] = (temp[i] + (LL)a[j] * b[j][i]) % m;

    memcpy(c, temp, sizeof temp);
}

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N] = {0};
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
            for (int k = 0; k < N; k ++ )
                temp[i][j] = (temp[i][j] + (LL)a[i][k] * b[k][j]) % m;

    memcpy(c, temp, sizeof temp);
}

int main()
{
    cin >> n >> m;

    int f1[N] = {1, 1, 1, 2, 1};
    int a[N][N] = {
{0, 1, 0, 2, 0}, 
{1, 1, 0, 1, 0},
{0, 0, 0, 1, 0},
{0, 0, 1, 1, 1},
{0, 0, 0, 0, 1}
    };

    n -- ;
    while (n)
    {
        if (n & 1) mul(f1, f1, a);  // res = res * a
        mul(a, a, a);  // a = a * a
        n >>= 1;
    }

    cout << f1[4] << endl;

    return 0;
}

NOIP2017列队

2022-06-16T14:04:13.000Z

题面

[NOIP2017 提高组] 列队

题目描述

Sylvia 是一个热爱学习的女孩子。

前段时间，Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。

Sylvia 所在的方阵中有 $n \times m$ 名学生，方阵的行数为 $n$ ，列数为 $m$ 。

为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中的学生从 $1$ 到 $n \times m$ 编上了号码（参见后面的样例）。即：初始时，第 $i$ 行第 $j$ 列的学生的编号是 $(i-1)\times m + j$ 。

然而在练习方阵的时候，经常会有学生因为各种各样的事情需要离队。在一天中，一共发生了 $q$ 件这样的离队事件。每一次离队事件可以用数对 $(x,y) (1 \le x \le n, 1 \le y \le m)$ 描述，表示第 $x$ 行第 $y$ 列的学生离队。

在有学生离队后，队伍中出现了一个空位。为了队伍的整齐，教官会依次下达这样的两条指令：

向左看齐。这时第一列保持不动，所有学生向左填补空缺。不难发现在这条指令之后，空位在第 $x$ 行第 $m$ 列。
向前看齐。这时第一行保持不动，所有学生向前填补空缺。不难发现在这条指令之后，空位在第 $n$ 行第 $m$ 列。

教官规定不能有两个或更多学生同时离队。即在前一个离队的学生归队之后，下一个学生才能离队。因此在每一个离队的学生要归队时，队伍中有且仅有第 $n$ 行第 $m$ 列一个空位，这时这个学生会自然地填补到这个位置。

因为站方阵真的很无聊，所以 Sylvia 想要计算每一次离队事件中，离队的同学的编号是多少。

注意：每一个同学的编号不会随着离队事件的发生而改变，在发生离队事件后方阵中同学的编号可能是乱序的。

输入格式

输入共 $q+1$ 行。

第一行包含 $3$ 个用空格分隔的正整数 $n, m, q$ ，表示方阵大小是 $n$ 行 $m$ 列，一共发生了 $q$ 次事件。

接下来 $q$ 行按照事件发生顺序描述了 $q$ 件事件。每一行是两个整数 $x, y$ ，用一个空格分隔，表示这个离队事件中离队的学生当时排在第 $x$ 行第 $y$ 列。

输出格式

按照事件输入的顺序，每一个事件输出一行一个整数，表示这个离队事件中离队学生的编号。

样例 #1

样例输入 #1

样例输出 #1

1
2
3

1
1
4

提示

【输入输出样例 $1$ 说明】

列队的过程如上图所示，每一行描述了一个事件。在第一个事件中，编号为 $1$ 的同学离队，这时空位在第一行第一列。接着所有同学向左标齐，这时编号为 $2$ 的同学向左移动一步，空位移动到第一行第二列。然后所有同学向上标齐，这时编号为 $4$ 的同学向上一步，这时空位移动到第二行第二列。最后编号为 $1$ 的同学返回填补到空位中。

【数据规模与约定】

测试点编号	$n$	$m$	$q$	其他约定
$1\sim 6$	$\le 10^3$	$\le 10^3$	$\le 500$	无
$7\sim 10$	$\le 5\times 10^4$	$\le 5\times 10^4$	$\le 500$	无
$11\sim 12$	$=1$	$\le 10^5$	$\le 10^5$	所有事件 $x=1$
$13\sim 14$	$=1$	$\le 3\times 10^5$	$\le 3\times 10^5$	所有事件 $x=1$
$15\sim 16$	$\le 3\times 10^5$	$\le 3\times 10^5$	$\le 3\times 10^5$	所有事件 $x=1$
$17\sim 18$	$\le 10^5$	$\le 10^5$	$\le 10^5$	无
$19\sim 20$	$\le 3\times 10^5$	$\le 3\times 10^5$	$\le 3\times 10^5$	无

数据保证每一个事件满足 $1 \le x \le n,1 \le y \le m$ 。

解法

树状数组

1. 前 50% 离散化

WC欢(du)乐(liu)赛题解

2022-01-27T13:30:44.000Z

T2
回滚莫队
T3

做法

因为给出了首字母，把首字母不符合的全部过滤掉

然后在剩下的里面用mt19937_64瞎猜

下一次猜的时候，依次假设未被过滤的每一个值是答案，求出与上一次猜相符的 good 和 silver

与返回的 good 和 silver 比对，进行过滤

继续用 mt19937_64 瞎猜

循环往复

然后83…

计算一下加权，手写一个决策树，就100pts了 ^_

NOIP2021报数

2022-01-15T11:59:44.000Z

看到题目，可能会以为是什么 mg 数学 or 线性筛
其实只要类似埃拉托色尼筛法，这样处理：

因为范围是 $10^7$ , 于是只要遍历 1 到 1e7 的每一个数，然后判断这个数里面有没有7，如果有，
就把它的倍数都遍历一下。。。
额，是不是很简单？

本来是会超时的，但是吸了氧。。。额

过了

PS：考场没注意吸氧，写了个打表，傻傻问了监考员说没事，然后爆零了。。

#include
using namespace std;
const int N = 1e7 + 10;
int a[N];
int b[N];

bool has7(int k)
{
while(k)
{
if(k % 10 == 7) return 1;
k /= 10;
}
return 0;
}

int main(void)
{
// a[7] = 1;
for(int i = 7; i < N; i++)
if(has7(i))
{
// if(i == 7) printf("OOOHH!!!\n");
for(int j = i; j < N; j += i)
{
a[j] = 1;
}
}

int cnt = 0;
for(int i = 0; i < N; i++)
if(!a[i])
{
b[++cnt] = i;
// if(i < 1000) printf("----%d\n", i);
}


    int T, x;
    scanf("%d", &T);
    for(int i = 1; i <= T; i++)
    {
        scanf("%d", &x);
        int *p = lower_bound(b + 1, b + cnt + 1, x);
        // printf("%d", )
        if(*p == x) printf("%d\n", *(p + 1));
        else printf("%d\n", -1);
    }
    return 0;
}

atcode_smallxor

2021-11-21T14:32:54.000Z

乍一看是数位DP, 其实不用那么麻烦的啦。

题目是要求 [L, R] 内满足 x xor N < N 的 x 个数.

考虑 N 的二进制拆分，若 N 的第 i 位为 1, 则从 $2^i$ 到 $2^{i+1}-1$ 都是满足要求的（想一想为什么）
然后统计每一个区间与[L, R] 的交并累加就可以了。。

SPFA求负环

2021-10-29T03:16:34.000Z

SPFA求负环有两种方法:

统计每个点的入队次数，如果 $\geq n$ 说明存在负环
统计最短路包含的边数，如果 $\gen n$ 说明存在负环

一般使用第 2 种方法，为什么呢? 看这张图

假设每一条边的权重都是 -1 那么这显然是一个负环，而我们用第一种方法要转 n - 1 圈，第二种只需要转 1 圈
当然这不是绝对的

如果题目给的数据范围很大，有可能会超时怎么办呢？
根据经验，如果所有点的入队次数总和很多，那么很有可能就是有负环。
一般取 N * 2 (小trick)

CSP2021

2021-10-29T02:00:00.000Z

普及组

T1 T4 没什么问题
T2 主要是懒惰排序，对于每次修改只修改一个地方，于是只要每次向左 or 右冒泡一下而且要写稳定排序
T3 check 写崩了如果一个合法IP端口号是个位数那么会被判定为不合法。

提高组

T1 简单模拟没什么问题三分好像不行
T2 是区间DP，情况有点多，分析要细致
f(l, r) 为 l 与 r 匹配的超级括号串
g(l, r) 为不匹配的
根据题目要求递推
T3 思路是考虑第一步选择 ‘L’ 或 ‘R’, 并找出与之相同的位置，分成两个栈，再每一次都取栈头栈尾做。
dfs 实现不优秀 40 优秀 100
T4 是由 k = 2 想到对原图求最小割
但是 dinic 太慢, 要建立原图的对偶图跑最短路
考虑将相邻的不同颜色附加点射线间的结点两两配对（容易注意到这样的结点个数一定为偶数或 1；结点数为 1 时显然仅存在一种颜色附加点，答案为 0）并分别按 $k\leq 2$ 的做法求最短路，再去掉这些最短路对应的原图的边集，那么答案方案所需要去掉的边集一定为某种配对方案对应的边集
这样就可以得到一个方案

csp7连测day7T4

2021-10-17T05:22:52.000Z

枚举字符串并计算概率

计 p(T, x) =

\cfrac{\Pi(S\frac{t_i}{i})}{A^{\sum t_i}_{\sum s_i}}

然后计算答案 P(T)

P(T) = 1 - \Pi_{x = 1}^{n}(1-p(T,x))

然后求所有P(T)的总和。

代码

#include 
using namespace std;
const int N = 110, P = 998244353;
int n, m, ans, vec[N], dm[N][N], cnt[N][10], w[N], dp[N];
char c[N];
int qpow(int a, int b)
{
    int res = 1;
    while (b)
    {
        if (b & 1)
            res = (1ll * res * a) % P;
        a = (1ll * a * a) % P, b >>= 1;
    }
    return res;
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%s", c + 1);
        for (int j = 1; j <= m; j++)
            cnt[i][c[j] - '0']++;
    }
    for (int i = 0; i <= m; i++)
    {
        dm[i][0] = 1;
        for (int j = 1; j <= i; j++)
        {
            dm[i][j] = (1ll * dm[i][j - 1] * (i - j + 1)) % P;
        }
    }
    for (int i = 1; i < (1 << n); i++)
    {
        int cntt = 0, sum = 0;
        for (int j = 0; j < n; j++)
        {
            if (i & (1 << j))
            {
                vec[++cntt] = j + 1;
            }
        }
        dp[0] = 1;
        for (int j = 1; j <= m; j++)
        {
            dp[j] = 0;
        }
        for (int j = 0; j <= 9; j++)
        {
            for (int l = 0; l <= m; l++)
            {
                w[l] = qpow(dm[l][l], P - 2);
                for (int k = 1; k <= cntt; k++)
                {
                    w[l] = (1ll * w[l] * dm[cnt[vec[k]][j]][l]) % P;
                }
            }
            for (int l = m; l >= 0; l--)
            {
                for (int k = l - 1; k >= 0; k--)
                {
                    dp[l] = (dp[l] + (1ll * dp[k] * w[l - k]) % P) % P;
                }
            }
        }
        for (int l = 0; l <= m; l++)
        {
            int tmp = (1ll * dp[l] * dm[l][l]) % P, prod = qpow(dm[m][l], P - 2);
            sum = (sum + (1ll * tmp * qpow(prod, cntt)) % P) % P;
        }
        if (cntt & 1)
            ans = (ans + sum) % P;
        else
            ans = (ans - sum + P) % P;
    }
    printf("%d\n", ans);
    return 0;
}

csp7连测day7T3

2021-10-17T05:05:28.000Z

如果边权 $k$ 在最小生成树中，那么这条边的位置已经在树上被确定了。
如果边权 $k$ 不在最小生成树中，那么这条边的两个端点此时必然属于同一个连通块 Ci，所以
这条边的方案数就是 $\sum E(C_i)$ ，其中 $E(C_i)$ 表示连通块 $C_i$ 中还有多少对点之间没有边，而这就等
于 $\cfrac{C_i \times (C_i −1)}{2} −E′(Ci)$ ，其中 E′(Ci) 是连通块 Ci 中已经连的边数，而我们之前总共连了 $k − 1$
条边，所以这条边的总方案数就是

(\sum{\frac{C_i\times (C_i - 1)}{2}}) - k + 1

根据乘法原理，方案数就是每条边的方案数乘积，而构造方案只需要动态维护当前在同一连通
块 $C_i$ 中的还未添加的边，每次从中任选一条作为边权为 k 的边。
考虑如何维护这些边，不难想到用并查集维护连通性，合并两个连通块时将从两边各选一个点
形成的边加入候选集合即可。

#include 
using namespace std;
const int N = 2010, P = 1e9 + 7;
struct Edge
{
int x, y, z;
bool operator<(Edge b)
{
return z < b.z;
}
} e[N];
int n, ans, cur, ok, f[N], d[N][N];
vector<int> v[N];
queueint, int>> q;
int findr(int x) { return (f[x] == x ? x : f[x] = findr(f[x])); }
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++)
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].z);

for (int i = 1; i <= n; i++)
f[i] = i, v[i].push_back(i);
sort(e + 1, e + n);
ans = ok = cur = 1;
for (int i = 1; i <= n * (n - 1) / 2; i++)
{
if (cur <= n - 1 && e[cur].z == i)
{
d[e[cur].x][e[cur].y] = d[e[cur].y][e[cur].x] = i;
int fx = findr(e[cur].x), fy = findr(e[cur].y);
f[fx] = fy;
int lenx = v[fx].size(), leny = v[fy].size();
for (int i = 0; i < lenx; i++)
{
for (int j = 0; j < leny; j++)
{
if (v[fx][i] != e[cur].x || v[fy][j] != e[cur].y)
q.push(make_pair(v[fx][i], v[fy][j]));
}
}
for (int i = 0; i < lenx; i++)
v[fy].push_back(v[fx][i]);
cur++;
}
else
{
if (q.empty())
{
ans = ok = 0;
break;
}
ans = (1ll * ans * (long long)(q.size())) % P;
d[q.front().first][q.front().second] =
d[q.front().second][q.front().first] = i;
q.pop();
}
}
printf("%d\n", ans);
if (ok)
{
for(int i = 1; i <= n; i++,puts(""))
for(int j = 1; j <= n; j++)
printf("%d ", d[i][j]);
}
return 0;
}

csp7连测day7T2

2021-10-17T03:27:03.000Z

离散化不难想到，关键是细节处理。
没有离散化的版本是这样的

#include 
using namespace std;

const int N = 1e5 + 10, M = 1e5 + 10;
int cut[M], l[N], r[N];
int T, n, m, mx;

int main(void)
{
    scanf("%d", &T);
    for (int _ = 1; _ <= T; _++)
    {
        memset(cut, 0, sizeof cut);
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d", l + i, r + i);
            mx = max(mx, r[i]);
            for (int j = l[i] + 1; j < r[i]; j++)
                cut[j]++;
        }
        sort(cut + 1, cut + mx + 1, greater<int>());
        int ans = n;
        for (int i = 1; i <= m; i++)
            ans += cut[i];
        printf("Case #%d: %d\n", _, ans);
    }
}

~~他甚至没有加差分优化~~

于是我们只要开若干个数组，存这段位置可以砍断的区间个数个长度，排序后直接模拟。

#include 
using namespace std;
const int N = 100000 + 10, M = 900000 + 10;
#define LL long long

int T, n;
LL m;

struct Data
{
LL l, r;
bool operator<(Data b)
{
return l != b.l ? l > b.l : r < b.r;
}

} a[N], b[M];

int main()
{
scanf("%d", &T);
int pp = 0;
while (T--)
{
scanf("%d%lld", &n, &m);
map ml, mr;
for (int i = 1; i <= n; i++)
scanf("%lld%lld", &a[i].l, &a[i].r),
ml[a[i].l]++, ml[a[i].r] = ml[a[i].r], mr[a[i].r]++;// 这里ml[a[i].r] = ml[a[i].r] 的作用是如果ml[a[i].r]没有建立就建立并设为0，否则不变

LL pre = 1, s = 0, len = 0;
for (auto z : ml)
{
LL x = z.first, y = z.second;
if (x - pre - 1 > 0)
b[++len] = {s, x - pre - 1};
s -= mr[x];
b[++len] = {s, 1};
s += ml[x];
pre = x;
}
sort(b + 1, b + 1 + len);

LL ans = 0;
for (int i = 1; i <= len; i++)
{
if (b[i].r < m)
{
m -= b[i].r;
ans += b[i].r * b[i].l;
}
else
{
ans += b[i].l * m;
break;
}
}

printf("Case #%d: %lld\n", ++pp, ans + n);
}
return 0;
}

csp7连测day7T1

2021-10-17T02:39:49.000Z

给两个字符串, A[0], B[0]

然后定义 A[i] = A[i - 1] + B[i - 1], B[i] = A[i - 1] + B[i - 1];
T 个询问

每次求 A[935] 的第 x 个数字

其实这题只要递归做就好了，关键是 $ 2^{935} $ 这个数字太大了……
考场上想到的办法是直接求出使得 $ A,B $ 大小最接近 $1e15$ 的一个数，但是有可能出现上一个还没到1e15, 下一个已经是负数了。。就错误了，但是我们可以直接预处理出从 1-935 的字符串长度，太长用 inf 代替，然后直接在函数内部判断大小并递归…

代码

#include 
using namespace std;
typedef long long ll;
const ll inf = 1e18;
const int N = 1e3 + 5, M = 1e4 + 5;

ll lenA[N], lenB[N];
char A[M], B[M];

char getA(int n, ll x);
char getB(int n, ll x);

char getA(int n, ll x)
{
if (!n) return A[x];

if (x < lenA[n - 1]) return getA(n - 1, x);
return getB(n - 1, x - lenA[n - 1]);
}

char getB(int n, ll x)
{
if (!n) return B[x];

if (x < lenB[n - 1]) return getB(n - 1, x);
return getA(n - 1, x - lenB[n - 1]);
}

int main()
{
int n, m, t;
scanf("%d%d%d", &n, &m, &t);
scanf("%s%s", &A, &B);

lenA[0] = n, lenB[0] = m;
for (int i = 1; i < N; i++)
lenA[i] = lenB[i] = min(inf, lenA[i - 1] + lenB[i - 1]);

while (t--)
{
ll x;
scanf("%lld", &x);
putchar(getA(935, x - 1));
putchar('\n');
}
return 0;
}

NOIP2013提高组华容道

2021-10-07T04:59:08.000Z

P1979

这题让空白格子乱走可以拿70分的好成绩。。

正解是保留有效状态 + 图论最短路

怎么保留呢？抽离有效状态的方法就是
给棋盘重新标号。不是我们通常说的 $(x, y) \rightarrow (x - 1) * m + y$ ,而是对状态进行标号。

对于某个棋子，假设到它的标号为
$k$ ，那么假设它为指定棋子的位置，当空格子在它上面时，这个状态为 $k+1$ ,下面时 $k+2$ …左边 $k+3$ ,右边 $k+4$ ,再下一个棋子，当空格子在它上面时 $k+5$ ，下面时 $k+6$ … 依此类推。

有用状态：空格子在指定棋子的上下左右。

有用状态的后继状态：

(1)本来空格子在指定棋子上下左右的状态的后继可以是空格子还是在棋子的上下左右，

也就是空格子围着指定格子转。

这个步数用bfs计算。

(2)本来空格子在指定棋子上下左右的后继状态是空格子与指定棋子交换了位置。步数为1。

用上面的方法记录状态就可以了

这题其实也可以启发式剪枝bfs,照样可以拿到满分。。

#include 
using namespace std;
const int N = 35;

const int inf = 99999999;
int n, m, q, ex, ey, bx, by, cx, cy;
bool mapp[N][N];
int xx[4] = {-1, 1, 0, 0};
int yy[4] = {0, 0, -1, 1};
int getnum(int ax, int ay, int t)
{
return ((ax - 1) * m + ay) * 4 - (4 - t);
}

struct blank
{
int x, y, step;
};

bool judge(int ax, int ay)
{
if (ax <= 0 || ax > n || ay <= 0 || ay > m)
return 0;
return mapp[ax][ay];
}
bool vis[N][N];
int bfs(int dx, int dy, int sx, int sy, int tx, int ty)
{
queue q;
memset(vis, 0, sizeof vis);
blank st;
st.x = sx;
st.y = sy;
st.step = 0;
vis[sx][sy] = 1;
q.push(st);
while (!q.empty())
{
blank uu = q.front();
q.pop();
if (uu.x == tx && uu.y == ty)
return uu.step;
for (int i = 0; i < 4; i++)
{
if (judge(uu.x + xx[i], uu.y + yy[i]))
{
if (vis[uu.x + xx[i]][uu.y + yy[i]])
continue;
if (uu.x + xx[i] == dx && uu.y + yy[i] == dy)
continue;
blank nxt;
nxt.x = uu.x + xx[i];
nxt.y = uu.y + yy[i];
nxt.step = uu.step + 1;
q.push(nxt);
vis[uu.x + xx[i]][uu.y + yy[i]] = 1;
}
}
}
return inf;
}
struct edge
{
int to, nxt, dis;
} b[5005];
int head[5005], tot;
void add(int u, int v, int w)
{
b[++tot].to = v;
b[tot].nxt = head[u];
b[tot].dis = w;
head[u] = tot;
}
bool ok[N][N][5];
void init()
{
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
{
if (!mapp[i][j])
continue;
for (int k = 0; k < 4; k++)
if (judge(i + xx[k], j + yy[k]))
ok[i][j][k] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 4; k++)
for (int l = k + 1; l < 4; l++)
{
if (ok[i][j][k] && ok[i][j][l])
{
int aa = getnum(i, j, k);
int bb = getnum(i, j, l);
int cc = bfs(i, j, i + xx[k], j + yy[k], i + xx[l], j + yy[l]);
if (cc == inf)
continue;
add(aa, bb, cc);
add(bb, aa, cc);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j < m; j++)
{
if (ok[i][j][3] && ok[i][j + 1][2])
{
int aa = getnum(i, j, 3);
int bb = getnum(i, j + 1, 2);
add(aa, bb, 1);
add(bb, aa, 1);
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j <= m; j++)
{
if (ok[i][j][1] && ok[i + 1][j][0])
{
int aa = getnum(i, j, 1);
int bb = getnum(i + 1, j, 0);
add(aa, bb, 1);
add(bb, aa, 1);
}
}
}
queue<int> Q;

bool viss[5000 + 10];
int d[5000 + 10];
void work()
{
memset(d, 128 / 3, sizeof d);
memset(viss, 0, sizeof viss);
for (int i = 0; i < 4; i++)
{
if (judge(bx + xx[i], by + yy[i]))
{
int nw = bfs(bx, by, ex, ey, bx + xx[i], by + yy[i]);
if (nw == inf)
continue;
int nq = getnum(bx, by, i);
d[nq] = nw;
Q.push(nq);
viss[nq] = 1;
}
}
while (!Q.empty())
{
int uu = Q.front();
Q.pop();
viss[uu] = 0;
for (int j = head[uu]; j; j = b[j].nxt)
{
int vv = b[j].to;
if (d[vv] > d[uu] + b[j].dis)
{
d[vv] = d[uu] + b[j].dis;
if (!viss[vv])
Q.push(vv), viss[vv] = 1;
}
}
}
int ans = inf;
for (int i = 0; i < 4; i++)
{
int qaq = getnum(cx, cy, i);
ans = min(ans, d[qaq]);
}
if (ans == inf)
puts("-1");
else
printf("%d\n", ans);
}
int main()
{
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> mapp[i][j];
init();
while (q--)
{
scanf("%d%d%d%d%d%d", &ex, &ey, &bx, &by, &cx, &cy);
if (bx == cx && by == cy)
{
puts("0");
continue;
}
if (!mapp[cx][cy])
{
puts("-1");
continue;
}
if (!mapp[bx][by])
{
puts("-1");
continue;
}
work();
}
return 0;
}

NOIP2013提高组转圈游戏

2021-10-07T04:44:54.000Z

P1965

推个公式，，不复杂的

Ans = (x + m \times 10^k) mod\ n

快速幂解决

~~(就是我不开 long long 只有70分，而题解里都没开 long long … 是我的实现不够好么~~

#include 
#define int long long
using namespace std;

int n, m, k, x;
int ksm(int a, int b)
{
    int res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % n;
        a = a * a % n;
        b >>= 1;
    }
    return res;
}
signed main()
{
    cin >> n >> m >> k >> x;
    cout << (x % n + m % n * ksm(10, k) % n) % n;
    return 0;
}

NOIP2013提高组火柴排队

2021-10-07T04:30:29.000Z

P1966

题目大意：
有两个序列A, B, 长度为n
定义分值为 $\sum\limits^{n}_{i=1} (A_i - B_i)^2$
求让 A, B 达到最大分值的最小交换次数

不满足单调性不能二分，怎么办？
研究题目性质!

我们看这个 $(A_i - B_i) ^ 2$ , 拆成这样 $A_i^2+B_i^2-2A_iB_i$ ,这里所有的 $A_i^2$ 和 $B_i^2$ 都是无法改变的，只能考虑改变 $A_iB_i$ 的值，学过贪心的我们肯定都知道, 有序优于无序。
我们令 $Q_{A_i} = B_i$ , 然后求一下逆序对的数目就好啦~

实践上

数值很大要注意离散化
题目要求取模哦 (否则会 80 分)
逆序对可以用树状数组或归并做，暴力会 TLE

下面给出代码

#include 
#define int long long // 不用 long long 也可以过
using namespace std;

const int N = 1e5 + 10;
const int P = 1e8 - 3;

int a[N], b[N], c[N], d[N], n, e[N], cnt;
int p[N];


// 这是逆序对模板
void merge_sort(int *A, int x, int y, int *T, int &cnt)
{
if (y - x > 1)
{
int m = x + (y - x) / 2;
int p = x, q = m, i = x;
merge_sort(A, x, m, T, cnt);
merge_sort(A, m, y, T, cnt);
while (p < m || q < y)
{
if (q >= y || (p < m && A[p] <= A[q]))
T[i++] = A[p++];
else
{
T[i++] = A[q++];
cnt += m - p;
                cnt %= P; // 别忘记取模
}
}
for (int i = x; i < y; i++)
A[i] = T[i];
}
}

signed main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i], c[i] = i;
    for (int i = 1; i <= n; i++)
        cin >> b[i], d[i] = i;

    sort(c + 1, c + n + 1, [&](const int &i, const int &j) -> bool
         { return a[i] < a[j]; });

    sort(d + 1, d + n + 1, [&](const int &i, const int &j) -> bool
         { return b[i] < b[j]; });

    for(int i = 1; i <= n; i++) e[c[i]] = d[i];

    cnt = 0;
    merge_sort(e, 1, n + 1, p, cnt);
    cout << cnt % P; // 别忘记取模（其实这里不取模也没关系，因为上面取模了
}

NOIP2013普及组表达式求值

2021-10-06T12:28:32.000Z

P1981

这道题其实本身很简单。。
以 ‘+’ 分段，然后对于每一个段(只有乘法)做，然后计算时不要忘了时刻 % 10000
我就是加上最后一个数没有 % 10000。。40分

40pts:

#include
#define int long long
using namespace std;
const int P = 10000;
string s;

int calc(int l, int r)
{
    if(l > r) return 0;
    stringstream ss(s.substr(l, r - l + 1));
    int base;
    ss >> base;
    char c; int xx;
    while(ss >> c >> xx)
    {
        xx = xx % P;
        if(c == '*') base = base * xx % P;
    }
    // printf("calc(%d, %d) = %d\n", l, r, base);
    return base;
}

signed main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    // cin >> s;
    getline(cin, s);
    int lastpos = 0, ans = 0;
    for(int i = 0; i < s.length(); i ++)
    {
        if(s[i] == '+') ans += calc(lastpos, i - 1), ans = ans % P, lastpos = i + 1;
    }
    ans = ans + calc(lastpos, s.length() - 1);
    printf("%d", ans);
}

100:

#include
#define int long long
using namespace std;
const int P = 10000;
string s;

int calc(int l, int r)
{
    if(l > r) return 0;
    stringstream ss(s.substr(l, r - l + 1));
    int base;
    ss >> base;
    char c; int xx;
    while(ss >> c >> xx)
    {
        xx = xx % P;
        if(c == '*') base = base * xx % P;
    }
    // printf("calc(%d, %d) = %d\n", l, r, base);
    return base;
}

signed main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    // cin >> s;
    getline(cin, s);
    int lastpos = 0, ans = 0;
    for(int i = 0; i < s.length(); i ++)
    {
        if(s[i] == '+') ans += calc(lastpos, i - 1), ans = ans % P, lastpos = i + 1;
    }
    ans = (ans + calc(lastpos, s.length() - 1)) % P;
    printf("%d", ans % P);
}

NOIP2014提高组联合权值

2021-10-05T05:43:47.000Z

核心：枚举中心点！
由于两点必然有一个中心，我们枚举这个中心就好啦
然后对于每一个点都计算一下贡献.
代码

#include 
using namespace std;
const int N = 1e6, M = 3e5;
struct Edge
{
    int e, ne;
    Edge() { e = ne = 0; }
} edge[N];
int head[M], idx = 0;
void add(int a, int b)
{
    idx++, edge[idx].e = b, edge[idx].ne = head[a], head[a] = idx;
}
long long w[M];
int main()
{
    int n;
    scanf("%d", &n);
    int a, b;
    for (int i = 0; i < n - 1; i++)
    {
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }
    for (int i = 1; i <= n; i++)
        scanf("%lld", &w[i]);
    long long sum = 0, maxn = 0;
    long long he, rmax;
    for (int i = 1; i <= n; i++)
    {
        int u = head[i];
        he = (rmax = w[edge[u].e]) % 10007;
        u = edge[u].ne;
        for (; u != 0; u = edge[u].ne)
        {
            sum = (sum + he * w[edge[u].e]) % 10007;
            maxn = max(maxn, rmax * w[edge[u].e]);
            he = (he + w[edge[u].e]) % 10007;
            rmax = max(rmax, w[edge[u].e]);
        }
    }
    printf("%lld %lld", maxn, (sum * 2) % 10007);
    return 0;
}

解方程这题
秦九韶公式可以加速计算
另外防止爆 long long 模大质数就好了

NOIP2014普及组螺旋矩阵

2021-10-05T02:35:34.000Z

P2239

观察一下规律，不难发现：

如果是第 $1$ 行，那么第 $j$ 列的数字就是 $j$
如果是第 $n$ 列，那么第 $i$ 行的数字就是 $n + i − 1$
如果是第 n 行，那么第 j 列的数字就是 $3 \times n - 2 - j + 1$
如果是第 1 列，那么第 i 行的数字就是 $4 \times n - 4 - i + 2$
然后

noip2015提高组运输计划

2021-10-04T12:00:44.000Z

首先 5 分还是很好拿的。只要dfs一下，记录从根到i的最大值和路径权值和，然后对于给出的数a, b, 输出sum[a] + sum[b] - max(mx[a], mx[b])

然后直接讲满分做法吧

二分 + 链长。
答案单调所以二分。
可以用树上差分 + 树剖 / 倍增来 check.

#include 
#include 
#include 
#include 
using namespace std;
const int N = 3e5 + 10;
struct edge
{
    int next, to, dis;
} e[2 * N], q[2 * N];
struct length
{
    int len, lca, u, v;
} len[N];
int head[N], cnt, headq[N], dis[N], maxlen, n, m, a[N], ans, s[N], num, ret, f[N]; //一堆变量
bool vis[N];
inline int read()
{
    int x = 0, ch = getchar();
    while (ch > '9' || ch < '0') ch = getchar();
    while (ch >= '0' && ch <= '9')
        x = (x << 3) + (x << 1) + (ch ^ '0'), ch = getchar();
    return x;
}
inline void add(int x, int y, int d)
{
    e[++cnt].next = head[x];
    e[cnt].to = y;
    e[cnt].dis = d;
    head[x] = cnt;
}
inline void add2(int x, int y)
{
    q[++cnt].next = headq[x], q[cnt].to = y, headq[x] = cnt;
}
int find(int x)
{
    return f[x] == x ? f[x] : f[x] = find(f[x]);
}
void dfs(int u, int pre)
{
    for (int i = head[u]; i; i = e[i].next)
    {
        int v = e[i].to;
        if (v == pre)
            continue;
        dfs(v, u);
        s[u] += s[v];
    }
    if (s[u] == num && a[u] > ret) ret = a[u];
}
inline bool check(int x)
{
    memset(s, 0, sizeof(s));
    num = ret = 0;
    for (int i = 1; i <= m; i++)
        if (len[i].len > x)
        {
            s[len[i].u]++;
            s[len[i].v]++;
            s[len[i].lca] -= 2;
            num++;
        }
    dfs(1, 0);
    if (maxlen - ret > x)
        return 0;
    return 1;
}
void tarjan(int u, int pre)
{
    for (int i = head[u]; i; i = e[i].next)
    {
        int v = e[i].to;
        if (v == pre)
            continue;
        dis[v] = dis[u] + e[i].dis;
        tarjan(v, u);
        a[v] = e[i].dis;
        int f1 = find(v);
        int f2 = find(u);
        if (f1 != f2)
            f[f1] = find(f2);
        vis[v] = 1;
    }
    for (int i = headq[u]; i; i = q[i].next)
        if (vis[q[i].to])
        {
            int p = (i + 1) >> 1;
            len[p].lca = find(q[i].to);
            len[p].len = dis[u] + dis[q[i].to] - 2 * dis[len[p].lca];
            maxlen = max(maxlen, len[p].len);
        }
}
int main()
{
    n = read(), m = read();
    for (int i = 1; i < n; i++)
    {
        int ai = read(), bi = read(), ti = read();
        add(ai, bi, ti);
        add(bi, ai, ti);
    }
    for (int i = 1; i <= n; i++)
        f[i] = i;
    cnt = 0;
    for (int i = 1; i <= m; i++)
    {
        int x = read(), y = read();
        len[i].u = x;
        len[i].v = y;
        add2(x, y);
        add2(y, x);
    }
    tarjan(1, 0);
    int l = 0, r = maxlen, mid;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (check(mid))
        {
            r = mid - 1;
            ans = mid;
        }
        else
            l = mid + 1;
    }
    printf("%d\n", ans);
    return 0;
}