NekoMio's Blog

将 Hexo 部署到 Cloudflare Workers

Thu, 17 Dec 2020 20:01:47 GMT

0. 起因

最近得知 Cloudflare Workers KV 有免费额度了，看起来可以搞一些有意思的东西，因为我自己 Blog 服务器在国内，所以想要通过分流的方法使国外直接访问 Cloudflare 以获得更好的体验。

1. 准备工作

想要把 Hexo Blog 部署到 Cloudflare Workers，当然要有一个 Hexo 的 Blog 了。同时也需要一个 Cloudflare 的账号~

2. 申请一个API key

3. 本地安装 Wrangler CLI 进行首次部署

安装 wrangler

既然有 Hexo，那必然会有 Nodejs 环境，那么，通过 npm 或者 yarn 安装 wrangler~

npm i @cloudflare/wrangler -g
# yarn global add @cloudflare/wrangler

初始化项目

进入你的 Hexo 根目录进行初始化

wrangler init --site my-static-site # 最后的名字可以改成自己喜欢的名字~

初始化之后，大概就可以看见目录中多出来的wrangler.toml文件和workers-site目录了。

修改配置

我们需要修改 wrangler.toml 来配置一下我们的项目

[site]
bucket = "./public"
entry-point = "workers-site"

最重要的是这两行，我们需要修改 bucket 的值为我们需要部署的目录，对于 Hexo 就是 ./public。

同时还需要修改上面的个人信息

account_id = ""
workers_dev = true
route = "www.nekomio.com/*"
zone_id = ""

account_id 大概登录就能看见，如果你没有绑定自己的域名可以暂时不管 route 和 zone_id

部署

这时候需要运行 wrangler config, 并输入之前我们得到的 API Token。

可以通过 preview 进行预览。

wrangler preview --watch

通过 publish 进行部署

wrangler publish

这时，我们以及可以打开Cloudflare上我们的网站了。

4. 自定义 Router

我这里使用了 Sukka 给出的一个配置文件，主要是将以 index.html 结尾的请求 301 跳转到不包含 index.html 的 URL，加长了 css 的 cache 时间。这里也放出来进行参考

import { getAssetFromKV, mapRequestToAsset } from '@cloudflare/kv-asset-handler'

addEventListener('fetch', event => {
  try {
    event.respondWith(handleEvent(event))
  } catch (e) {
    if (DEBUG) {
      return event.respondWith(
        new Response(e.message || e.toString(), {
          status: 500,
        }),
      )
    }
    event.respondWith(new Response('Internal Error', { status: 500 }))
  }
})

async function handleEvent(event) {
  const { origin, pathname: path, search } = new URL(event.request.url);
  if (path.endsWith('/index.html')) {
    return new Response(null, {
      status: 301,
        headers: {
          'Location': `${origin}${path.substring(0, path.length - 10)}${search}`,
          'Cache-Control': 'max-age=3600'
        }
    });
  }
  if (path === '/atom.xml') {
    return getAssetFromKV(event, {
      cacheControl: {
        edgeTtl: 60 * 60,
        browserTtl: 2 * 60 * 60
      }
    });
  }
  
  if (path.startsWith('/css/'))  {
    const response = await getAssetFromKV(event, {
      cacheControl: {
        edgeTtl: 365 * 24 * 60 * 60,
        browserTtl: 365 * 24 * 60 * 60
      }
    });
    // getAssetFromKV 不会添加 immutable，所以需要手动覆盖掉 Cache-Control
    response.headers.set('cache-control', `public, max-age=${365 * 24 * 60 * 60}, immutable`);
    return response;
  }
  
  const response = await getAssetFromKV(event, {
    cacheControl: {
      edgeTtl: 60 * 60,
      browserTtl: 5 * 60
    }
  });
  
  response.headers.set('X-XSS-Protection', '1; mode=block');
  return response;
}

最后，就结束了~~

这个是官方给出的免费的限制，流量不大的话还是够用的。如果文章数量比较多的话，大概每天部署的次数比较有限。

Workers 功能
- 包括 100,000 个请求/天 (UTC+0)
- 每个请求最多占用 10 毫秒 CPU 时间
- 第一个请求后的延迟最低
键值存储功能
- 每天 100,000 次读取操作
- 每天 1,000 次写入、删除、列出操作

计算导论与程序设计基础复习指北

Wed, 18 Dec 2019 09:52:47 GMT

观前提示

本文中所有的代码都不保证可靠性，仅为一个便于理解的例子，如出现问题，本人概不负责，也请大家指正。

简介

本文简单的梳理了计导中的知识。

计算机程序设计语言

定义: 用于书写计算机程序的语言，用于表达和描述要加工的数据以及求解问题的步骤和过程。是根据预先定义的规则（语法）、由一个有限字母表上的字符构成的字符串的总体。

计算模型

图灵机
1. 组成
  1. 一个无限长的纸带
  2. 一个读写头
  3. 内部状态
  4. 一个程序，用于对这个盒子进行控制
2. 原理
  1. 根据程序的命令以及它的内部状态进行磁带的读写、移动，直至得到最后的结果。
自动机(有限状态自动机)
1. 组成
  1. 一个有限状态控制器
  2. 一个读头
  3. 一条写有字符的输入带
2. 工作原理
  1. 读头在输入带上从左向右移动，每当读头从带上读到一个字符时，便引起控制器状态的改变，同时读头右移一个符号的位置
3. 状态转移图
  1. 点: 表示一种状态
  2. 边: 表示一种转移关系

C语言（划重点）

语法

1. 定义

变量定义 C 中常见的变量有以下几种

int a;
long long b;
char c;
float b;
double e;

函数定义

return_type function_name( parameter list )
{
   body of the function
}

数组定义

一维数组

type arrayName[arraysize];

多维数组

type arrayName[arraysize1][..]..[..][arraysizen];

指针定义

type *var-name;

type 是var-name所指向的类型

2. 输入输出

输入

int scanf(const char *format, ...);
char *gets(char *s);
char getchar(void);

scanf()是格式化输入,
gets()能读入一整行的字符,
getcchar()能读入单独的一个字符

输出

int printf(const char *format, ...);
int puts(const char *s);
int putchar(int c);

与上面类似
printf() 是格式化输出,
puts() 可以输出一个字符串,
putchar() 可以输出一个单独的字符

格式化符号

字符	描述
`d`	有符号十进制数值int
`u`	十进制unsigned int
`f`	double型输出10进制定点表示
`s`	char数组字符串
`c`	unsigned char

修饰符

字符	描述
`l`	对于整数类型，表示一个long尺寸的整型参数。对于浮点类型，表示一个double尺寸的整型参数。
`ll`	对于整数类型，表示一个long long尺寸的整型参数。

更多内容参考printf format string

流程控制

判断语句

if (...) {

} else {

}

可以没有else 有多个嵌套 2. switch

switch(...) {
    case ..:
        do some thing
        break;
    case ..:
        do some thing
        break;
    /* case的数量是任意的*/
    default: /* 可选的 */
        do some thing
}

循环

while

while(condition)
{

}

for ( init; condition; increment ) {

}

do...while

do
{

}while( condition );

运算符

算术运算符 +-*/%
关系运算符 ==,!=,>,<,>=,<=
逻辑运算符 &&,||,!

结构体

struct struct_name {
    type val_name_1;
    ...
    type val_name_n;
} s1;

struct struct_name s2;

typedef struct {
    type val_name_1;
    ...
    type val_name_n;
}struct_name; 

truct_name s1, s2;

一个结构体可以简单的理解为将多个变量组合成了一个变量。
在定义结构体之后，我们相当于构造了一种新的变量类型。
我们可以用这种变量类型来定义变量。
访问结构体中的变量需要使用 . 运算符。

指针

指向变量的指针
指针变量存储了另一个变量的地址。比如

int a;
int *p = &a;

这样 p 变量中就储存了 a 的地址。
我们访问一个变量
可以直接通过变量名访问
也可以通过它的地址来间接访问它的值。

指向指针的指针
我们知道指针也是一种变量
所以我们也可以定义一个指向指针的指针，形如 int **p。
我们这样理解，p 指向了另一个指针，而那一个指针指向的是一个变量。
我们可以直接将一个指针解引用后的值当做一个完整的变量。也就是说我们可以将 *p 当做一个整体来理解，它在一定意义上与它指向的变量的变量名等价。
指向函数的指针

return_type (*function_name)( parameter list );

请注意第一个括号不能省略，否则将会变成返回一个指针的函数
函数指针可以指向一个函数，其中 parameter list 中的参数名称可以省略，但不能省略参数名称。类似于函数声明。

指向结构体的指针
指向结构体的指针与指向变量的指针类似。
问题在于 . 运算符的优先级高于 *运算符的优先级，所以我们要去元素的话 (*a).b 一定要加括号。
这样很麻烦，所以我们有一种新的运算符 ->，则 (*a).b 等价于 a->b 这样更加简洁易懂。

函数传参与返回值

传参为按值传递，在函数内函数的参数不会影响原来的值。
如果想要修改原来的值，那么我们要传入的值一定是要修改的值的地址。
将数组作为函数参数时，只可以省略第一维的大小，而且其他维的大小在传参的时候都要对应，而且传入数组时，数组内的元素可以被修改。
函数无法返回一个数组。

字符串

在C语言中字符串就是字符数组。
字符串的结尾是'\0'，对应ASCII码为0
在string.h 库中有不少关于字符串的常用函数如strlen(), strcpy()。
我这里不再展开，大家可以再网上查阅相关内容。

算法

1. 交换两个变量的值

假设我们有两个变量a和b, 我们要交换他们

int temp = a;
a = b;
b = temp;

2. 排序算法

我们主要学习一下冒泡排序
冒泡排序第k次循环将第k大（第k小）的数字移动到第k前（第k后）
然后在n-1轮之后就能获得一个排好序的数组

我们设 a[i] 是需要排序的数组。

for (int i = 1; i < n; i++) {
    for (int j = 1; j <= n - i; j++) {
        if (a[j] > a[j + 1]) {
            int temp = a[j];
            a[j] = a[j + 1];
            a[j + 1] = temp;
        }
    }
}

3. 二分查找

我们先考虑最简单的二分法
假设我们有一个长度为 n 已经从小到大排序好的数组 a[i]。
我们想知道一个数 $x$ 是否在 a[i] 中出现。
这时我们可以通过二分来找这个数

int l = 0, r = n, ans = n + 1;
while (l <= r) {
    int mid = (l + r) / 2;
    if (a[mid] == x) {
        ans = mid;
        break;
    }
    if (a[mid] < x) l = mid + 1;
    else (a[mid] > x) r = mid - 1;
}

最后求出的 ans 就是 $x$ 的位置，如果没有找到的话 ans 就是 n + 1

另一种二分为二分答案。
二分答案是指，我们对一个问题答案的值进行二分。
通过逻辑判断得出我们真正的答案是比我们分出的值大还是小，从而修改 l,r 的值。
二分答案的条件是我们问题的答案具有单调性，
比如说，a 如果可行，那么比 a 大的一定不可行， a 如果不可行，比 a 小的一定不可行。
这样我们就可以进行二分了。

写在最后

由于篇幅有限，我很多内容不能写的很详细，也省略了一部分内容，很多内容还是要依靠大家自己复习。
希望大家能认真复习，祝愿大家在期末中取得好成绩。

计导成绩更多的来自于平时的积累，要多打代码，多刷OJ题，当代码量达到一定水平之后，量变就会引发质变，会让大家对编程有一个全新的理解。

Min25 筛法的原理与应用

Sun, 11 Aug 2019 14:58:06 GMT

0. 定义

$\mathbb{P}$ 表示质数集

1. 用途

Min25筛是一种求积性函数$f(x)$的前缀和$\sum_{i=1}^{N}{f(i)}$的一种方法。

2. 条件

$f(n)$ 为积性函数 (废话)
$f(p)$ 在$p$处为关于$p$的低次多项式

3. 做法

首先，我们定义一个函数$g_k(n, m) = \sum_{i=1}^{n}{i^k[i \in \mathbb{P};or;M(i) > P_m]}$

当 $n < P_m^2$ 时 $g_k(n, m) = g_k(n, m - 1)$
否则我们要从$g_k(n, m)$中删除$M(i)=P_m$的合数的贡献，也就是

$$\sum_{i=1}^{n}{i^k[i \in \mathbb{C};and;M(i) = P_m]} =P_m^k(g_k(\lfloor\frac{n}{P_m}\rfloor, m - 1)-\sum_{i=1}^{m-1}{P_i^k})$$

之后，我们要计算我们的函数$f(x)$

我们定义$h(n, m)=\sum_{i=1}^n{f(i)[M(i) \ge P_m]}$

先考虑质数，因为$f(p)$ 满足第二个条件，所以我们可以用$g$函数构造出$f(p)$的答案。
- 那么设$f(p) = \sum{a_k*p^k}$
- 则可以得出$\sum_{i=m}^{|P|}{f(P_i)[P_i<n]} = \sum{a_k*g_k(n, |P|) - \sum_{i=1}^{m-1}{f(P_i)}}$
然后考虑合数
- 枚举合数的最小质因子为$P_i$, 和最小质因子的次数为$t$,
  可以将合数写为$P_i^t \times j (M(j) \ge P_{i+1}, j \le \lfloor \frac{n}{P_i^t} \rfloor)$
- 则这些合数的贡献为 $f(P_i^t)((\sum_{j=1}^{\frac{n}{P_i^t}}{f(j)[M(j) \ge P_{i+1}]}) + [t \neq 1]) = f(P_i^t) (h(\lfloor \frac{n}{P_i^t} \rfloor, i + 1) + [t \neq 1])$
综合一下

$$ h(n,m) =\sum{a_kg_k(n, |P|)}-\sum_{i=1}^{m-1}{f(P_i)}+\sum_{i=m}^{|P|}{\sum_{t \ge 1 , P_i^t \le n}{f(P_i^t)(h(\lfloor \frac{n}{P_i^t} \rfloor, i + 1) + [t \neq 1])}} $$

模板库

Wed, 31 Jul 2019 11:04:10 GMT

算法 (AG)
1. 网络流 (NF)
  1. 网络流线性规划
    1. 上下界网络流
    2. 最小割
    3. 费用流
  2. Edmond-Karp (EK)
    1. Capacity Scaling
    2. Dinic&SAP
    3. HLPP
2. 差分约束 (DC)
3. 通用线性规划 (LP)
  1. 单纯形算法
4. 分数规划 (FP)
5. 贪心 (GE)
6. 分治 (DAC)
  1. 序列分治
    1. CDQ&~~整体二分&线段树分治~~
    2. [ ] 快速排序
      1. 快速选择
        
        Median of Medians
  2. 树分治
    1. 点/边分治
    2. 重链剖分
      1. 树上启发式合并
      2. 长链剖分
7. 搜索 (SR)
  1. 搜索优化与剪枝
    1. A* (AS)
    2. 迭代加深搜索 (ID)
  2. 折半搜索 (MIM)
8. 随机化及近似 (RAN)
  1. 爬山
  2. 模拟退火
  3. ~~遗传算法~~
  4. ~~机器学习基础~~
9. 离线逆序
  1. 莫队算法
10. 散列 (HS)
数据结构 (DS)
1. 栈 (STK) => STL
2. 队列 (QUE) => STL
3. 散列表 (HST)
4. 堆 (HP)
  1. 二叉堆
  2. 可并堆
5. 二叉查找树 (BST)
  1. 堆树 (THP)
  2. Treap
  3. 红黑树 (RBT)
  4. 替罪羊树 (SGT)
6. 树状数组 (BIT)
7. 线段树 (SGM)
8. 并查集 (UFS)
  1. 带权并查集
  2. 路径压缩
  3. 按秩合并
9. Sparse Table (ST)
10. K维树 (KDT)
11. 动态树
  1. 点/边分治树 (DCT)
  2. Link-Cut Tree (LCT)
  3. 欧拉回路树 (ETT)
  4. AAA Tree & Top Tree
12. 动态图
图论 (GT)
1. 最小生成树
  1. Prim 算法 (PM)
  2. Kruskal 算法 (KS)
    1. Boruvka 算法
  3. 最小树形图
    1. 朱-刘算法
  4. 斯坦纳树
2. 最短路径
  1. dijkstra 算法 (DJ)
  2. Bellman-Ford 算法 (BFD)
    1. Johnson 算法
  3. Floyd 算法 (FL)
3. 欧拉路&哈密顿路
4. 连通性
  1. 点/边双连通分量 (BCC)
  2. 强连通性 (SCC)
  3. 支配树
5. 匹配、划分与覆盖
  1. KM 算法 (KM)
    1. 交错树
    2. 带花树算法 (BL)
    3. Tutte 矩阵与一般图匹配
  2. 覆盖集与独立集
  3. 稳定婚姻问题与 GS 算法 (GS)
  4. Hall 定理
  5. DAG 路径覆盖
  6. Dilworth 定理
6. 2-SAT
7. 虚树
8. 仙人掌
  1. 圆方树
9. 弦图与区间图
10. 图的树分解
11. 最小割
  1. 最小割树
  2. Stoer-Wagner 算法
12. 平面图
  1. 平面图对偶图
13. 网格图
计算几何 (CG)
1. 几何向量
2. 二维凸包
  1. 凸包算法
    1. 卷包裹法
    2. 动态凸包
  2. 三维凸包
  3. 半平面交
3. 旋转卡壳
4. 三角剖分
  1. V图
5. 路径规划
代数 (AB)
1. 微积分基础
  1. Simpson 积分算法
2. 线性代数
  1. 矩阵基础
    1. 高斯消元
    2. 拟阵
    3. Matrix-Tree 定理
    4. 线性递推
3. 多项式与幂级数
  1. DFT/FFT (FT)
    1. NTT
    2. Bluestein 算法
  2. 多项式基本运算
    1. 多项式除法
    2. 多项式基本初等函数
  3. FWT (FWT)
    1. 子集变换
4. 抽象代数
  1. 置换群
    1. Schreier-Sims 算法
数论 (NT)
1. 同余和整除
  1. 欧几里得算法
    1. 扩展欧几里得算法
    2. 类欧几里得算法
  2. 欧拉定理
  3. 二次剩余
  4. 原根及离散对数
    1. BSGS
  5. lucas 定理
2. 质数与简单数论函数
  1. 埃氏筛
  2. 欧拉筛
  3. 莫比乌斯反演
  4. 数论函数快速求和
    1. 杜教筛
    2. 洲阁筛
  5. 素性测试
    1. Miller-Robin (MR)
    2. Pollard's Rho 因子分解
组合计数 (CE)
1. 计数原理
  1. 容斥原理
2. 计数数列
  1. 斯特林数
  2. 卡特兰数
  3. 伯努利数
3. 生成函数 (GF)
4. 杨氏矩阵
5. Burnside 引理
  1. Polya 定理
博弈论与信息论 (GI)
1. 博弈基础
  1. 组合游戏
    1. 博弈树与 DAG 模型
    2. Sprague-Grundy 函数 (SG)
    3. Nim (NIM)
      1. Nim 积
    4. 威佐夫博弈
  2. 不平等博弈
    1. 超现实数
  3. 不完全信息博弈
2. 通信与数据压缩
  1. 校验码
  2. 哈夫曼编码
  3. 游程编码
形式语言，自动机与串处理 (FAS)
1. 串处理 (STR)
  1. 模式匹配
    1. KMP 算法 (KMP) && EXKMP
    2. AC 自动机
    3. Shift-And 算法
  2. 字典树 (TRI)
    1. 后缀树
      1. 后缀数组 (SA)
      2. 后缀自动机 (SAM)
  3. Border
    1. Periodicity 引理
  4. 回文串
    1. manacher 算法
    2. 回文自动机 (PAM)
2. 形式语言
  1. 正则表达式 (RE)
  2. 有限状态自动机 (DFA)
3. 并行计算

CDQ

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 800005;
struct Query
{
    int x, y, op, val, id, pos;
    bool operator < (const Query &a) const
    {
        return x == a.x ? op < a.op : x < a.x;
    }
} Ask[MAXN], tmp[MAXN];
int n, m, Ans[MAXN];
#define lowbit(_) ((_)&(-_))
struct BIT
{
    int Sum[2000005];
    void add(int x, int c)
    {
        for (int i = x; i <= n; i += lowbit(i))
            Sum[i] += c;
    }
    int Query(int x)
    {
        int ans = 0;
        for (int i = x; i > 0; i -= lowbit(i))
            ans += Sum[i];
        return ans;
    }
}bit;
void add()
{
    int x1, y1, x2, y2;
    scanf ("%d%d%d%d", &x1, &y1, &x2, &y2);
    ++Ans[0];
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y1 - 1, Ask[m].val = 1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2    , Ask[m].y = y2    , Ask[m].val = 1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y2    , Ask[m].val =-1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2    , Ask[m].y = y1 - 1, Ask[m].val =-1, Ask[m].op = 1;
}
void CDQ(int l, int r)
{
    if (l == r)
        return;
    int mid = l + r >> 1, l1 = l, l2 = mid + 1;
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid && !Ask[i].op)
            bit.add(Ask[i].y, Ask[i].val);
        if (Ask[i].id > mid && Ask[i].op)
            Ans[Ask[i].pos] += Ask[i].val * bit.Query(Ask[i].y);
    }
    for (int i = l; i <= r; i++)
        if (Ask[i].id <= mid && !Ask[i].op)
            bit.add(Ask[i].y, -Ask[i].val);
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid)
            tmp[l1++] = Ask[i];
        else tmp[l2++] = Ask[i];
    }
    for (int i = l; i <= r; i++)
        Ask[i] = tmp[i];
    CDQ(l, mid);
    CDQ(mid + 1, r);
    return;
}
int main()
{
    freopen("mokia.in", "r", stdin);
    freopen("mokia.out", "w", stdout);
    int op;
    scanf ("%d%d", &op, &n);
    while (1)
    {
        scanf ("%d", &op);
        if (op == 1)
        {
            m++;
            scanf ("%d%d%d", &Ask[m].x, &Ask[m].y, &Ask[m].val);
        }
        else if (op == 2)
            add();
        else break;
    }
    for (int i = 1; i <= m; i++)
        Ask[i].id = i;
    sort(Ask + 1, Ask + m + 1);
    CDQ(1 ,m);
    for (int i = 1; i <= Ans[0]; i++)
        printf ("%d\n", Ans[i]);
}

点分治

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}

const int MAXN = 20005;

struct edge
{
	int END, next;
	int v;
}v[MAXN << 1]; 
int first[MAXN], p;
void add(int a, int b, int c)
{
	v[p].END = b;
	v[p].next = first[a];
	v[p].v = c;
	first[a] = p++;
}
int size[MAXN], Max[MAXN], ans, sum, t[3], d[MAXN];
bool vis[MAXN];
int root;
void Get_root(int rt, int fa)
{
	size[rt] = 1, Max[rt] = 0;
	for (int i = first[rt]; i != -1; i = v[i].next)
	{
		if (!vis[v[i].END] && v[i].END != fa)
		{
			Get_root(v[i].END, rt);
			size[rt] += size[v[i].END];
			Max[rt] = max(Max[rt], size[v[i].END]);
		}
	}
	Max[rt] = max(Max[rt], sum - size[rt]);
	if (Max[rt] < Max[root]) root = rt;
}

void dfs(int rt, int fa)
{
	t[d[rt]]++;
	for (int i = first[rt]; i != -1; i = v[i].next)
	{
		if (!vis[v[i].END] && v[i].END != fa)
		{
			d[v[i].END] = (d[rt] + v[i].v) % 3;
			dfs(v[i].END, rt);
		}
	}
}

int Calc(int rt, int x)
{
	t[0] = t[1] = t[2] = 0;
	d[rt] = x;
	dfs(rt, 0);
	return t[1] * t[2] * 2 + t[0] * t[0];
}

void Solve(int rt)
{
	ans += Calc(rt, 0);
	vis[rt] = 1;
	for (int i = first[rt]; i != -1; i = v[i].next)
	{
		if (!vis[v[i].END])
		{
			ans -= Calc(v[i].END, v[i].v);
			root = 0, sum = size[v[i].END];
			Get_root(v[i].END, 0);
			Solve(root);
		}
	}
}

int gcd(int a, int b)
{
	return b == 0 ? a : gcd(b, a % b);
}

int main()
{
	memset (first, -1, sizeof (first));
	int n = read();
	int a, b, c;
	for (int i = 1; i < n; i++)
	{
		a = read(), b = read(), c = read() % 3;
		add(a, b, c);
		add(b, a, c);
	}
	Max[0] = sum = n;
	Get_root(1, 0);
	Solve(root);
	int G = gcd(ans, n * n);
	printf ("%d/%d\n", ans / G, n * n / G);
}

Astar

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
struct edge {
  int END, v, next;
} ZHENG[10005], FAN[10005];
struct A {
  int END, f, g;
  bool operator<(const A &a) const {
    if (f == a.f) return a.g < g;
    return a.f < f;
  }
};
int first_zheng[1005], first_fan[1005], p;
int dis[1005];
int n;
int s;
void add(int a, int b, int c);
void spfa(int a);
int Astar(int k);
int main() {
  freopen("cowjog.in", "r", stdin);
  freopen("cowjog.out", "w", stdout);
  // cin>>n>>m;
  memset(first_fan, -1, sizeof(first_fan));
  memset(first_zheng, -1, sizeof(first_zheng));
  p = 1;
  int m, a, b, c, K;
  scanf("%d%d%d", &n, &m, &K);
  for (int i = 1; i <= m; i++) {
    scanf("%d%d%d", &a, &b, &c);
    if (a > b)
      add(a, b, c);
    else
      add(b, a, c);
  }
  spfa(1);
  for (int k = 1; k <= K; k++) {
    s = 0;
    cout << Astar(k) << endl;
  }
  // while(1);
}
void add(int a, int b, int c) {
  ZHENG[p].END = b;
  ZHENG[p].v = c;
  ZHENG[p].next = first_zheng[a];
  FAN[p].END = a;
  FAN[p].v = c;
  FAN[p].next = first_fan[b];
  first_zheng[a] = p;
  first_fan[b] = p++;
}
void spfa(int a) {
  memset(dis, 0x3f, sizeof(dis));
  dis[a] = 0;
  bool flag[1005] = {0};
  queue<int> p;
  p.push(a);
  flag[a] = 1;
  while (!p.empty()) {
    int tmp = p.front();
    flag[tmp] = 0;
    p.pop();
    for (int i = first_fan[tmp]; i != -1; i = FAN[i].next) {
      if (dis[FAN[i].END] > dis[tmp] + FAN[i].v) {
        dis[FAN[i].END] = dis[tmp] + FAN[i].v;
        if (!flag[FAN[i].END]) {
          flag[FAN[i].END] = 1;
          p.push(FAN[i].END);
        }
      }
    }
  }
}
int Astar(int k) {
  priority_queue<A> p;
  A s1, s2;
  s1.END = n;
  s1.g = 0;
  s1.f = s1.g + dis[n];
  p.push(s1);
  while (!p.empty()) {
    s2 = p.top();
    p.pop();
    if (s2.END == 1) {
      s++;
      if (s == k) return s2.g;
    }
    for (int i = first_zheng[s2.END]; i != -1; i = ZHENG[i].next) {
      s1.END = ZHENG[i].END;
      s1.g = s2.g + ZHENG[i].v;
      s1.f = s1.g + dis[ZHENG[i].END];
      p.push(s1);
    }
  }
  return -1;
}

模拟退火

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <climits>
#include <ctime>
using namespace std;
const double pi = acos(-1.);
const double eps = 1e-10;
const int seed = time(0);
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
double Rand()
{
    return 1.0 * rand() / RAND_MAX;
}
struct Point
{
    double x, y, k;
    Point(double _x = 0, double _y = 0): x(_x), y(_y) {
        k = atan2(y, x);
    }
    Point operator - (const Point &_x)
    {
        return Point(x - _x.x, y - _x.y);
    }
    double operator * (const Point &_x)
    {
        return x * _x.y - y * _x.x;
    }
    bool operator < (const Point &_x) const
    {
        return k > _x.k;
    }
}a[10], tmp[10];
int cnt = 0;
double area(Point *x, int n)
{
    double ans = 0;
    cnt++;
    sort(x + 1, x + n + 1);
    Point t(0, 0);
    for (int i = 1; i <= n - 1; i++)
        ans += (x[i] - t) * (x[i + 1] - t);
    ans += (x[n] - t) * (x[1] - t);
    return fabs(ans);
}
int r[10];
bool cmp(const int &a, const int &b)
{
    return a > b;
}
double dis(Point &x, Point &y)
{
    return (x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y);
}
bool cmp1(Point x, Point y)
{
    double s = (x - tmp[1]) * (y - tmp[1]);
    if (fabs(s) <= eps) return dis(x, tmp[1]) < dis(y, tmp[1]);
    return s > 0;
}
int st[10], top;
double Calc(Point *x, int n)
{
	memcpy(tmp, x, sizeof (tmp));
    int k = 0;
    for (int i = 1; i <= n; i++)
        if (tmp[i].x < tmp[k].x && tmp[i].y < tmp[k].y || !k)
            k = i;
    swap(tmp[1], tmp[k]);
    sort(tmp + 2, tmp + n + 1, cmp1);
    top = 0;
    st[++top] = 1;
    for (int i = 2; i <= n; i++)
    {
        while (top > 1 && (tmp[st[top]] - tmp[st[top - 1]]) * (tmp[i] - tmp[st[top]]) < 0) top--;
        st[++top] = i;
    }
    for (int i = 1; i <= top; i++)
        tmp[i] = tmp[st[i]];
    return area(tmp, top);
}
double T = 1e9, mint = 1e-9, delta = 1 - 1e-2;
int loop = 50;
double w[10];
int main()
{
    // freopen ("1.out", "w", stdout);
    srand(seed);
    int n = read();
    for (int i = 1; i <= n; i++) r[i] = read();
    for (int i = 1; i <= n; i++) w[i] = Rand() * 2 * pi;
    for (int i = 1; i <= n; i++) a[i].x = cos(w[i]) * r[i], a[i].y = sin(w[i]) * r[i];
    double ans = Calc(a, n);
    while (T > mint)
    {
        for (int i = 1; i <= loop; i++)
        {
            int t = rand() % n + 1;
            double tmp_w = w[t];
            w[t] = w[t] + Rand() * 2 * pi * T;
            // if (w[t] > 2 * pi) w[t] -= 2 * pi;
            a[t].x = cos(w[t]) * r[t], a[t].y = sin(w[t]) * r[t];
            double tmp = Calc(a, n);
            // printf ("%.2f\n", (tmp - ans) / T);
            // printf ("%.2f\n", exp((tmp - ans) / T));
            if (tmp > ans || exp((tmp - ans) / T) > Rand()) 
                ans = tmp;
            else
            {
                w[t] = tmp_w;
                a[t].x = cos(w[t]) * r[t], a[t].y = sin(w[t]) * r[t];
            }
        }
        T *= delta;
    }
    printf ("%.10f\n", ans / 2);
    // while (1);
}

莫队

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int a[50005], in[50005];
int block = 500;
struct Query
{
	int l, r, ID;
	bool operator < (const Query &b) const 
	{
		return in[l] == in[b.l] ? r > b.r : l < b.l;
	}
}Q[200005];
int cnt[1000005];
int out[200005];
int main()
{
	int n, m, ans = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);	
		in[i] = (i - 1) / block + 1;
		cnt[a[i]]++;
		if(cnt[a[i]] == 1)
			ans++;
	}
	scanf("%d", &m);
	for (int i = 1; i <= m; i++)
		scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].ID = i;
	sort(Q + 1, Q + m + 1);
	int l = 1, r = n + 1;
	for (int i = 1; i <= m; i++)
	{
		while(l < Q[i].l) {cnt[a[l]]--; if(cnt[a[l]] == 0) ans--; l++;}
		while(l > Q[i].l) {l--; cnt[a[l]]++; if(cnt[a[l]] == 1) ans++;}
		while(r > Q[i].r) {cnt[a[r]]--; if(cnt[a[r]] == 0) ans--; r--;}
		while(r < Q[i].r) {r++; cnt[a[r]]++; if(cnt[a[r]] == 1) ans++;}
		out[Q[i].ID] = ans;
	}
	for (int i = 1; i <= m; i++)
		printf("%d\n", out[i]);
}

离散化

cnt = 0;
for (int i = 1; i <= n; i++) {
  a[i] = read();
  Hash[++cnt] = a[i];
}
sort(Hash + 1, Hash + cnt + 1);
cnt = unique(Hash + 1, Hash + cnt + 1) - Hash - 1;
for (int i = 1; i <= n; i++) {
  a[i] = lower_bound(Hash + 1, Hash + cnt + 1, a[i]) - Hash;
}

Hash_Table

const int MAXN = 200000, BASE = 76543;
struct Hash_Table
{
    struct edge
    {
        int Id, next;
        long long Max;
    }v[MAXN];
    int first[BASE + 2], p;
    Hash_Table()
    {
        memset (first, -1, sizeof (first));
        p = 0;
    }
    void clear()
    {
        memset (first, -1, sizeof (first));
        p = 0;
    }
    long long &operator[](int x)
    {
        int H = x % BASE;
        for (int i = first[H]; i != -1; i = v[i].next)
            if (v[i].Id == x)
                return v[i].Max;
        v[p].Id = x;
        v[p].next = first[H];
        first[H] = p++;
        return v[p - 1].Max = -INF;
    }
}Hash;

Treap

struct Treap
{
    struct Node
    {
        int s, key, Max_Num, Max_Size;
        data x;
        Node *ch[2];
        Node(data sa)
        {
            ch[0] = ch[1] = NULL;
            s = 1, x = sa, key = rand();
            Max_Num = Max_Size = 0;
        }
#define size(_) ((_) ? (_)->s : 0)
        void Pushup()
        {
            s = size(ch[0]) + size(ch[1]) + 1;
        }
        void Pushdown()
        {
            if (ch[0])
            {
                ch[0]->Max_Num = max(ch[0]->Max_Num, Max_Num);
                ch[0]->Max_Size = max(ch[0]->Max_Size, Max_Size);
                Max_Morale[ch[0]->x.ID] = max(Max_Morale[ch[0]->x.ID], ch[0]->Max_Num);
                Max_Solidarity[ch[0]->x.ID] = max(Max_Solidarity[ch[0]->x.ID], ch[0]->Max_Size);
            }
            if (ch[1])
            {
                ch[1]->Max_Num = max(ch[1]->Max_Num, Max_Num);
                ch[1]->Max_Size = max(ch[1]->Max_Size, Max_Size);
                Max_Morale[ch[1]->x.ID] = max(Max_Morale[ch[1]->x.ID], ch[1]->Max_Num);
                Max_Solidarity[ch[1]->x.ID] = max(Max_Solidarity[ch[1]->x.ID], ch[1]->Max_Size);
            }
            Max_Num = Max_Size = 0;
        }
    } * root;
    Treap()
    {
        root = NULL;
    }
    Node *Merge(Node *A, Node *B)
    {
        if (!A)
            return B;
        if (!B)
            return A;
        if (A->key < B->key)
        {
            A->Pushdown();
            A->ch[1] = Merge(A->ch[1], B);
            A->Pushup();
            return A;
        }
        else
        {
            B->Pushdown();
            B->ch[0] = Merge(A, B->ch[0]);
            B->Pushup();
            return B;
        }
    }
    typedef pair<Node *, Node *> DNode;
    DNode Split(Node *rt, int k)
    {
        if (!rt)
            return DNode(NULL, NULL);
        DNode o;
        rt->Pushdown();
        if (size(rt->ch[0]) >= k)
        {
            o = Split(rt->ch[0], k);
            rt->ch[0] = o.second;
            rt->Pushup();
            o.second = rt;
        }
        else
        {
            o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
            rt->ch[1] = o.first;
            rt->Pushup();
            o.first = rt;
        }
        return o;
    }
    Node *kth(int k)
    {
        DNode x = Split(root, k - 1);
        DNode y = Split(x.second, 1);
        Node *ans = y.first;
        root = Merge(Merge(x.first, ans), y.second);
        return ans;
    }
    int Rank(Node *rt, data x)
    {
        if (!rt)
            return 0;
        return x <= rt->x ? Rank(rt->ch[0], x) : Rank(rt->ch[1], x) + size(rt->ch[0]) + 1;
    }
    void Insert(data x)
    {
        int k = Rank(root, x);
        if (root)
        {
            root->Max_Size = max(root->Max_Size, size(root));
            root->Max_Num = max(root->Max_Num, x.x);
            Max_Morale[root->x.ID] = max(root->Max_Num, Max_Morale[root->x.ID]);
            Max_Solidarity[root->x.ID] = max(root->Max_Size, Max_Solidarity[root->x.ID]);
        }
        DNode y = Split(root, k);
        Node *n = new Node(x);
        root = Merge(Merge(y.first, n), y.second);
    }
    void remove(data x)
    {
        int k = Rank(root, x);
        DNode a = Split(root, k);
        DNode b = Split(a.second, 1);
        delete b.first;
        root = Merge(a.first, b.second);
    }
};

替罪羊树

namespace Scapegoat_Tree
{
    const int MAXN = 1e6 + 10;
    const double alpha = 0.756;
    struct Node
    {
        Node *ch[2];
        int key, s, cover;
        bool exist;
        void Pushup()
        {
            s = ch[0]->s + ch[1]->s + exist;
            cover = ch[0]->cover + ch[1]->cover + 1;
        }
        bool isBad()
        {
            return ((ch[0]->cover > cover * alpha + 5) || (ch[1]->cover > cover * alpha + 5));
        }
    };
    struct Stree 
    {
        Node mem_poor[MAXN];
        Node *tail, *root, *null, *ls[MAXN];
        Node *bc[MAXN]; int bc_top, top;
        Node *NewNode(int key)
        {
            Node *o = bc_top ? bc[--bc_top] : tail++;
            o->ch[0] = o->ch[1] = null;
            o->s = o->cover = o->exist = 1;
            o->key = key;
            return o;
        }
        void Travel(Node *rt)
        {
            if (rt == null) return;
            Travel(rt->ch[0]);
            if (rt->exist) ls[++top] = rt;
            else bc[bc_top++] = rt;
            Travel(rt->ch[1]);
        }
        Node *Divide(int l, int r)
        {
            if (l > r) return null;
            int mid = (l + r) >> 1;
            Node *o = ls[mid];
            o->ch[0] = Divide(l, mid - 1);
            o->ch[1] = Divide(mid + 1, r);
            o->Pushup();
            return o;
        }
        void ReBuild(Node *&rt)
        {
            top = 0;
            Travel(rt);
            rt = Divide(1, top);
        }
        Node ** Insert(Node *&rt, int val)
        {
            if (rt == null) 
            {
                rt = NewNode(val);
                return &null;
            }
            else
            {
                Node **res = Insert(rt->ch[val >= rt->key], val);
                rt->Pushup();
                if (rt->isBad()) res = &rt;
                return res;
            }
        }
        void erase(Node *rt, int id)
        {
            rt->s--;
            int offset = rt->ch[0]->s + rt->exist;
            if (rt->exist && id == offset)
            {
                rt->exist = false;
                return;
            }
            else
            {
                if (id <= offset) erase(rt->ch[0], id);
                else erase(rt->ch[1], id - offset);
            }
        }
        Stree()
        {
            tail = mem_poor;
            null = tail++;
            null->ch[0] = null->ch[1] = null;
            null->cover = null->s = null->key = 0;
            root = null; bc_top = 0;
        }
        void Insert(int val)
        {
            Node **rt = Insert(root, val);
            if (*rt != null) ReBuild(*rt);
        }
        int Rank(int val)
        {
            Node *rt = root;
            int ans = 1;
            while (rt != null)
            {
                if (rt->key >= val) rt = rt->ch[0];
                else
                {
                    ans += rt->ch[0]->s + rt->exist;
                    rt = rt->ch[1];
                }
            }
            return ans;
        }
        int Kth(int k)
        {
            Node *rt = root;
            while (rt != null)
            {
                if (rt->ch[0]->s + 1 == k && rt->exist) return rt->key;
                else if (rt->ch[0]->s >= k) rt = rt->ch[0];
                else k -= rt->ch[0]->s + rt->exist, rt = rt->ch[1];
            }
        }
        void erase(int k)
        {
            erase(root, Rank(k));
            if (root->s < alpha * root->cover) ReBuild(root);
        }
    };
}

FFT

const int MAXN = 60005 << 2;
const double pi = acos(-1.0);
#define Complex complex<double>
int r[MAXN], n;
Complex a[MAXN], b[MAXN];
void DFT(Complex *a, int f)
{
	for (int i = 0; i < n; i++)
		if (r[i] > i) swap(a[i], a[r[i]]);
	for (int i = 1; i < n; i <<= 1)
	{
		Complex wn(cos(pi / i), f * sin(pi / i));
		for (int j = 0; j < n; j += i << 1)
		{
			Complex w = 1;
			for (int k = 0; k < i; k++, w *= wn)
			{
				Complex x = a[j + k], y = w * a[j + k + i];
				a[j + k] = x + y, a[j + k + i] = x - y;
			}
		}
	}
}
int c[MAXN], m;
void FFT(Complex *a, Complex *b)
{
	int l = 0;
	for (n = 1, m <<= 1; n < m; n <<= 1) ++l;
	for (int i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
	DFT(a, 1), DFT(b, 1);
	for (int i = 0; i < n; i++) a[i] *= b[i];
	DFT(a, -1);
	for (int i = 0; i < n; i++) a[i] /= n;
	for (int i = 0; i < m; i++) c[i] = (int)(a[i].real() + 0.5);
}

NTT

const int MAXN = 2e6;
const long long MOD = 998244353;
long long A[MAXN], B[MAXN], N;
long long Inv;
int rev[MAXN];
long long pow_mod(long long a, long long b, long long P) {
  long long ans = 1;
  while (b) {
    if (b & 1) ans = ans * a % P;
    b >>= 1;
    a = a * a % P;
  }
  return ans;
}
void FFt(long long *a, int op) {
  long long w, wn, t;
  for (int i = 0; i < N; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int k = 2; k <= N; k <<= 1) {
    wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k, MOD);
    for (int j = 0; j < N; j += k) {
      w = 1;
      for (int i = 0; i < (k >> 1); i++, w = w * wn % MOD) {
        t = a[i + j + (k >> 1)] * w % MOD;
        a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
        a[i + j] = (a[i + j] + t) % MOD;
      }
    }
  }
  if (op == -1)
    for (int i = 0; i < N; i++) a[i] = a[i] * Inv % MOD;
}
void FFt(const int *a, const int *b, int *res, int n) {
  N = 1;
  while (N < n) N <<= 1;
  Inv = pow_mod(N, MOD - 2, MOD);
  for (int i = 0; i < N; i++)
    if (i & 1)
      rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
    else
      rev[i] = (rev[i >> 1] >> 1);
  for (int i = 0; i < N; i++) A[i] = a[i], B[i] = b[i];
  FFt(A, 1), FFt(B, 1);
  for (int i = 0; i < N; i++) A[i] = A[i] * B[i] % MOD;
  FFt(A, -1);
  for (int i = 0; i < N; i++) res[i] = A[i];
}

树状数组

long long Sum[MAXN];
int Num[MAXN];
#define lowbit(_) ((_) & (-_))
void add(int x, int c) {
  for (int i = x; i <= cnt; i += lowbit(i)) Sum[i] += c, Num[i]++;
}
long long Query(int x) {
  long long ans = 0;
  for (int i = x; i > 0; i -= lowbit(i))
    ans += Sum[i];
  return ans;
}
int query(int x) {
  int ans = 0;
  for (int i = x; i > 0; i -= lowbit(i))
    ans += Num[i];
  return ans;
}

线段树

const int N = 100005;
int Sum[N << 2];
#define lch l, m, rt << 1
#define rch m + 1, r, rt << 1 | 1
void Pushup(int rt)
{
    Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1]; 
}
void Update(int x, int c, int l, int r, int rt)
{
    if (l == r)
    {
        Sum[rt] = c;
        return;
    }
    int m = l + r >> 1;
    if (x <= m) Update(x, c, lch);
    else Update(x, c, rch);
    Pushup(rt);
}
void buildtree(int l, int r, int rt)
{
    if (l == r)
    {
        Sum[rt] = 1;
        return;
    }
    int m = l + r >> 1;
    buildtree(lch);
    buildtree(rch);
    Pushup(rt);
}
int find(int w, int l, int r, int rt)
{
    if (l == r)
        return l;
    int m = l + r >> 1;
    if (Sum[rt << 1] >= w)
        return find(w, lch);
    else
        return find(w - Sum[rt << 1], rch);
}
int Query(int w, int L, int R, int l, int r, int rt)
{
    if (L == l && R == r)
    {
        if (Sum[rt] < w)
            return -Sum[rt];
        return find(w, l, r, rt);
    }
    int m = l + r >> 1;
    if (R <= m)
        return Query(w, L, R, lch);
    else if (L > m)
        return Query(w, L, R, rch);
    else
    {
        int s1 = Query(w, L, m, lch);
        if (s1 > 0) return s1;
        int s2 = Query(w + s1, m + 1, R, rch);
        if (s2 > 0) return s2;
        return s1 + s2;
    }    
}
int Query_Sum(int L, int R, int l, int r, int rt)
{
    if (L == l && R == r)
        return Sum[rt];
    int m = l + r >> 1;
    if (R <= m)
        return Query_Sum(L, R, lch);
    if (L > m)
        return Query_Sum(L, R, rch);
    return Query_Sum(L, m, lch) + Query_Sum(m + 1, R, rch);
}

并查集

int find(int x) {
  if (fa[x] != x) fa[x] = find(fa[x]);
  return fa[x];
}

ST

int Max[(50005 << 1) + 200][16], Min[(50005 << 1) + 200][16];

int QueryMax(int l, int r)
{
    if (l > N || r < 0) return -0x3f3f3f3f;
    if (l <= 0) l = 1;
    if (r > N) r = N;
    int k = 0;
    while ((1 << k) <= (r - l + 1)) k++; k--;
    return max(Max[l][k], Max[r - (1 << k) + 1][k]);
}

int QueryMin(int l, int r)
{
    if (l > N || r < 0) return 0x3f3f3f3f;
    if (l <= 0) l = 1;
    if (r > N) r = N;
    int k = 0;
    while ((1 << k) <= (r - l + 1)) k++; k--;
    return min(Min[l][k], Min[r - (1 << k) + 1][k]);
}
int main () {
    for (int i = 1; i <= 15; i++)
        for (int j = 1; j <= N; j++)
        {
            Max[j][i] = max(Max[j][i - 1], Max[j + (1 << (i - 1))][i - 1]);
            Min[j][i] = min(Min[j][i - 1], Min[j + (1 << (i - 1))][i - 1]);
        }
}

KD-Tree

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
  
using namespace std;
  
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
  
const int INF = 0x3f3f3f3f;
const double alpha = 0.756;
const int MAXN = 5e5 + 5;
  
int now;
  
struct Point
{
    int d[2];
    int &operator[](const int &x)
    {
        return d[x];
    }
    inline bool operator < (const Point &x) const
    {
        return d[now] == x.d[now] ? d[now ^ 1] < x.d[now ^ 1] : d[now] < x.d[now];
    }
}a[MAXN], cur;
  
#define dis(_, __) (\
    int(abs(_[0] - __[0]) + abs(_[1] - __[1]))\
)
  
#define size(_) ((_) ? (_)->s : 0)
  
struct Node
{
    Node *ch[2];
    Point v;
    int s, d;
    int Max[2], Min[2];
    Node(Point x)
    {
        ch[0] = ch[1] = NULL;
        v = x;
        s = 1, d = now;
        Max[0] = Min[0] = x[0];
        Max[1] = Min[1] = x[1];
    }
    Node(){;}
    inline bool operator < (const Node &x) const
    {
        return v < x.v;
    }
    bool IsBad()
    {
        return ((size(ch[0]) > s * alpha) || (size(ch[1]) > s * alpha));
    }
    void Pushup(Node *x)
    {
        if (!x) return;
        for (int i = 0; i <= 1; i++) Min[i] = min(Min[i], x->Min[i]);
        for (int i = 0; i <= 1; i++) Max[i] = max(Max[i], x->Max[i]);
        s += x->s;
    }
    int min_dis()
    {
        int ans = 0;
        ans += max(Min[0] - cur[0], 0) + max(cur[0] - Max[0], 0);
        ans += max(Min[1] - cur[1], 0) + max(cur[1] - Max[1], 0);
        return ans;
    }
}*root;
  
inline void Build(Node *&rt, int l, int r, int d = 0)
{
    if (l > r) return;
    int mid = l + r >> 1;
    now = d;
    nth_element(a + l, a + mid, a + r + 1);
    rt = new Node(a[mid]);
    Build(rt->ch[0], l, mid - 1, d ^ 1);
    Build(rt->ch[1], mid + 1, r, d ^ 1);
    rt->s = 1;
    rt->Pushup(rt->ch[0]);
    rt->Pushup(rt->ch[1]);
}
  
Node **res;
  
inline void Insert(Node *&rt)
{
    if (rt == NULL)
    {
        rt = new Node(cur);
        res = NULL;
        return;
    }
    now = rt->d;
    if (cur < rt->v) Insert(rt->ch[0]);
    else Insert(rt->ch[1]);
    rt->s = 1;
    rt->Pushup(rt->ch[0]);
    rt->Pushup(rt->ch[1]);
    if (rt->IsBad()) res = &rt;
}
  
Node *st[MAXN << 1];
int top = 0;
  
inline void Travel(Node *&rt)
{
    if (!rt) return;
    Travel(rt->ch[0]);
    st[++top] = rt;
    Travel(rt->ch[1]);
}
  
inline int cmp(const Node *x, const Node *y)
{
    return x->v < y->v;
}
  
inline Node *Divide(int l, int r, int d)
{
    if (l > r) return NULL;
    int mid = l + r >> 1;
    now = d;
    nth_element(st + l, st + mid, st + r + 1, cmp);
    Node *rt = st[mid];
    rt->ch[0] = Divide(l, mid - 1, d ^ 1);
    rt->ch[1] = Divide(mid + 1, r, d ^ 1);
    rt->s = 1;
    rt->Max[0] = rt->Min[0] = rt->v[0];
    rt->Max[1] = rt->Min[1] = rt->v[1];
    rt->Pushup(rt->ch[0]);
    rt->Pushup(rt->ch[1]);
}
  
inline void ReBuild(Node *&rt)
{
    top = 0;
    int d = rt->d;
    Travel(rt);
    rt = Divide(1, top, d);
}
  
inline void Insert(Point x)
{
    cur = x;
    Insert(root);
    if (res != NULL)
        ReBuild(*res);
}
  
int Min_ans;
  
inline void Query(Node *rt)
{
    if (!rt) return;
    // if (rt->min_dis() > Min_ans) return;
    Min_ans = min(Min_ans, dis(rt->v, cur));
    int dis_l = rt->ch[0] ? rt->ch[0]->min_dis() : INF;
    int dis_r = rt->ch[1] ? rt->ch[1]->min_dis() : INF;
    if (dis_l < dis_r)
    {
        Query(rt->ch[0]);
        if (dis_r < Min_ans) Query(rt->ch[1]);
    }
    else
    {
        Query(rt->ch[1]);
        if (dis_l < Min_ans) Query(rt->ch[0]);
    }
}
  
inline int Query(Point x)
{
    cur = x;
    Min_ans = INF;
    Query(root);
    return Min_ans;
}
  
int main()
{
    // freopen("1.in", "r", stdin);
    // freopen("2.out", "w", stdout);
    int n, m;
    n = read(), m = read();
    for (int i = 1; i <= n; i++)
        a[i][0] = read(), a[i][1] = read();
    Build(root, 1, n);
    Point x;
    while (m--)
    {
        int t = read();
        if (t == 1)
        {
            x[0] = read(), x[1] = read();
            Insert(x);
        }
        else
        {
            x[0] = read(), x[1] = read();
            printf ("%d\n", Query(x));
        }
    }
}

LCT

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}

const int MAXN = 10010;

struct Node
{
	Node *f, *ch[2];
	bool IsRoot, Mark;
	Node()
	{
		f = ch[0] = ch[1] = NULL;
		IsRoot = 1, Mark = 0;
	}
}*null, *Q[MAXN];
Node *NewNode()
{
	Node *o = new Node();
	o->f = o->ch[0] = o->ch[1] = null;
	return o;
}
bool son(Node *rt)
{
	return rt->f->ch[1] == rt;
}
inline void Pushflip(Node *rt)
{
	if (rt == null) return;
	rt->Mark ^= 1, swap(rt->ch[0], rt->ch[1]);
}
inline void Pushdown(Node *rt)
{
	if (rt->Mark)
	{
		Pushflip(rt->ch[0]);
		Pushflip(rt->ch[1]);
		rt->Mark = 0;
	}
}
inline void rotate(Node *rt)
{
	if (rt->IsRoot) return;
	Node *fa = rt->f, *Grand = fa->f;
	Pushdown(fa), Pushdown(rt);
	int k = son(rt), kk = son(fa);
	fa->ch[k] = rt->ch[k ^ 1];
	if (rt->ch[k ^ 1] != null) rt->ch[k ^ 1]->f = fa;
	rt->ch[k ^ 1] = fa, fa->f = rt, rt->f = Grand;
	if (!fa->IsRoot) Grand->ch[kk] = rt;
	else fa->IsRoot = 0, rt->IsRoot = 1; 
}
inline void Clear(Node *rt)
{
	if (!rt->IsRoot) Clear(rt->f);
	Pushdown(rt);
}

inline void Splay(Node *rt)
{
	for (Clear(rt); !rt->IsRoot; rotate(rt))
		if (!rt->f->IsRoot)
			rotate(son(rt) == son(rt->f) ? rt->f : rt);
}

inline void Access(Node *rt)
{
	for (Node *pre = null; rt != null; pre = rt, rt = rt->f)
	{
		Splay(rt);
		rt->ch[1]->IsRoot = 1;
		pre->IsRoot = 0;
		rt->ch[1] = pre;
	}
}

inline void MakeRoot(Node *rt)
{
	Access(rt);
	Splay(rt);
	Pushflip(rt);
}

inline void link(Node *a, Node *b)
{
	MakeRoot(a);
	a->f = b;
}

inline void cut(Node *a, Node *b)
{
	MakeRoot(a);
	Access(b);
	Splay(b);
	Pushdown(b);
	b->ch[0]->IsRoot = 1;
	b->ch[0]->f = null;
	b->ch[0] = null;
}

inline Node* find(Node *rt)
{
	if (rt->ch[0] != null) return find(rt->ch[0]);
	return rt;
}

inline bool Judge(Node *a, Node *b)
{
	while (a->f != null) a = a->f;
	while (b->f != null) b = b->f;
	return a == b;
}

int main()
{
	int n = read(), m = read();
	null = new Node();
	null->ch[0] = null->ch[1] = null->f = null, null->IsRoot = null->Mark = 0;
	for (int i = 1; i <= n; i++)
		Q[i] = NewNode();
	int a, b;
	char c[10];
	while (m--)
	{
		scanf ("%s", c);
		if (c[0] == 'C')
		{
			a = read(), b = read();
			link(Q[a], Q[b]);
		}
		else if (c[0] == 'Q')
		{
			a = read(), b = read();
			puts(Judge(Q[a], Q[b]) ? "Yes" : "No");
		}
		else
		{
			a = read(), b = read();
			cut(Q[a], Q[b]);
		}
	}
}

Dijkstra

#include <bits/stdc++.h>
const int N = 1e6 + 1;
using namespace std;
struct edge {
  int END, next, v;
} v[N * 2];
int first[N], p;
void add(int a, int b, int c) {
  v[p].END = b;
  v[p].v = c;
  v[p].next = first[a];
  first[a] = p++;
}
int n, m, S;
typedef pair<int, int> T;
int dis[N];
int main() {
  scanf("%d%d%d", &n, &m, &S);
	memset (first, -1, sizeof (first));
  for (int i = 1; i <= m; i++) {
    int x, y, z;
    scanf("%d%d%d", &x, &y, &z);
    add(x, y, z);
  }
  memset(dis, 0x3f, sizeof(dis));
  dis[S] = 0;
  T X;
  X.first = 0, X.second = S;
  priority_queue<T, vector<T>, greater<T> > Q;
  Q.push(X);
  while (!Q.empty()) {
    X = Q.top();
    Q.pop();
    int x = X.second;
    if (dis[x] < X.first) continue;
    for (int i = first[x]; i; i = v[i].next) {
      int y = v[i].END;
      if (dis[y] > dis[x] + v[i].v) {
        dis[y] = dis[x] + v[i].v;
        X.first = dis[y];
        X.second = y;
        Q.push(X);
      }
    }
  }
  for (int i = 1; i <= n; i++) printf("%d ", dis[i]);
  return 0;
}

SPFA

int dis[N];
bool flag[N];
queue<int> q;
bool Spfa(int x)
{
	memset(dis, 0x3f, sizeof (dis));
	memset(flag, 0, sizeof (flag));
	dis[x] = 0;
	flag[x] = 1;
	q.push(x);
	while (!q.empty())
	{
		int k = q.front();
		q.pop();
		flag[k] = 0;
		for (int i = first[k]; i != -1; i = v[i].next)
		{
			if (dis[v[i].END] > dis[k] + v[i].v)
			{
				dis[v[i].END] = dis[k] + v[i].v;
				if (!flag[v[i].END])
				{
					flag[v[i].END] = 1;
					q.push(v[i].END);
				}
			}
		}
	}
	return 0;
}

多项式

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 1e6 * 4;
const int MOD  = 998244353;
const int L = (1 << 18) + 1;
const int LM = (1 << 16) + 1;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int N, Inv, rev[MAXN];
int Sum = 0, n, m;
struct data
{
    int e, f, g, id;
}s[60005];
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int ans[MAXN], cnt;
void insert(int a, int b, int c, int d, int id)
{
    if (b == 0)
    {
        ans[id] = ((1ll * a * Sum) + (1ll * c * n)) % MOD * pow_mod(d, MOD - 2) % MOD;
        return;
    }
    s[++cnt].f = (1ll * b * c - 1ll * a * d) % MOD;
    b = pow_mod(b, MOD - 2);
    s[cnt].e = 1ll * a * b % MOD, s[cnt].g = 1ll * d * b % MOD;
    b = 1ll * b * b % MOD; s[cnt].f = 1ll * s[cnt].f * b % MOD;
    if (s[cnt].f < 0) s[cnt].f += MOD;
    s[cnt].id = id;
}
void Init(int x)
{
    N = 1;
    while (N < (x << 1)) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
}
inline int Calc(int x)
{
    N = 1;
    while (N < (x << 1)) N <<= 1;
    return N;
}
void FFt(int *a, int op)
{
    int w, wn, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = 1ll * w * wn % MOD)
            {
                t = 1ll * a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = 1ll * a[i] * Inv % MOD;
}
int tmp[MAXN], x[MAXN];
void Get_Inv(int *a, int *b, int n)
{
    if (n == 1) return b[0] = pow_mod(a[0], MOD - 2), void();
    Get_Inv(a, b, n + 1 >> 1);
    Init(n);
    for (int i = 0; i < n; i++) tmp[i] = a[i];
    for (int i = n; i < N; i++) tmp[i] = 0;
    FFt(tmp, 1), FFt(b, 1);
    for (int i = 0; i < N; i++) 
        b[i] = 1ll * b[i] * ((2 - 1ll * b[i] * tmp[i] % MOD + MOD) % MOD) % MOD;
    FFt(b, -1);
    for (int i = n; i < N; i++) b[i] = 0;
}
int Get_mod(int *a, int ra, int *b, int rb, int *c)
{
    while (ra && !a[ra - 1]) --ra;
    while (rb && !b[rb - 1]) --rb;
    if (ra < rb)
    {
        memcpy (c, a, ra << 2);
        memset (c + ra, 0, (rb - ra) << 2);
        return rb;
    }
    static int tmp1[MAXN], tmp2[MAXN];
    int rc = ra - rb + 1;
    int l = Calc(rc);
    for (int i = 0; i < l; i++) tmp1[i] = 0;
    reverse_copy(b, b + rb, tmp1);
    for (int i = 0; i < l; i++) tmp2[i] = 0; 
    Get_Inv(tmp1, tmp2, rc);
    for (int i = rc; i < l; i++) tmp2[i] = 0;
    reverse_copy(a, a + ra, tmp1);
    for (int i = rc; i < l; i++) tmp1[i] = 0;
    Init(rc), FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1); 
    reverse(tmp1, tmp1 + rc); 
    Init(ra);
    for (int i = 0; i < rb; i++) tmp2[i] = b[i];
    for (int i = rb; i < N; i++) tmp2[i] = 0;
    for (int i = rc; i < N; i++) tmp1[i] = 0;
    FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1);
    for (int i = 0; i < rb; i++) c[i] = (a[i] - tmp1[i] + MOD) % MOD;
    for (int i = rb; i < N; i++) c[i] = 0;
    while (rb && !c[rb - 1]) --rb;
    return rb;
}
int Solve0(int *a, int l, int r)
{
    int ra = r - l + 2;
    if (ra <= 256)
    {
        memset(a, 0, ra << 2), a[0] = 1;
        for (int i = l; i <= r; i++)
            for (int v = x[i], j = i - l; j != -1; j--)
            {
                a[j + 1] = (a[j + 1] + a[j]) % MOD;
                a[j] = 1ll * a[j] * v % MOD;
            }
        return ra;
    }
    int mid = l + r >> 1;
    int *f1 = a, r1 = Solve0(f1, l, mid);
    int *f2 = a + r1, r2 = Solve0(f2, mid + 1, r);
    N = 1;
    while (N < ra) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    static int tmp1[L], tmp2[L];
    memcpy(tmp1, f1, r1 << 2), memset (tmp1 + r1, 0, (N - r1) << 2), FFt(tmp1, 1);
    memcpy(tmp2, f2, r2 << 2), memset (tmp2 + r2, 0, (N - r2) << 2), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) a[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(a, -1);
    return ra;
}
int *p[L];
int sta[MAXN];
int mem[LM << 4], *head = mem;
inline int Solve1(int id, int l, int r)
{
    int ra = r - l + 2;
    if (ra <= 256)
    {
        int *f = p[id] = head; head += ra;
        memset (f, 0, ra << 2), 0[f] = 1;
        for (int i = l; i <= r; i++)
            for (int v = (MOD - sta[i]) % MOD, j = i - l; j != -1; j--)
                f[j + 1] = (f[j + 1] + f[j]) % MOD, f[j] = 1ll * f[j] * v % MOD;
        return ra;
    }
    int mid = l + r >> 1;
    int r1 = Solve1(id << 1, l, mid), *f1 = p[id << 1];
    int r2 = Solve1(id << 1 | 1, mid + 1, r), *f2 = p[id << 1 | 1];
    N = 1;
    while (N < ra) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    static int tmp1[LM], tmp2[LM];
    memcpy(tmp1, f1, r1 << 2), memset (tmp1 + r1, 0, (N - r1) << 2), FFt(tmp1, 1);
    memcpy(tmp2, f2, r2 << 2), memset (tmp2 + r2, 0, (N - r2) << 2), FFt(tmp2, 1);
    int *f = p[id] = head; head += ra;
    for (int i = 0; i < N; i++) f[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(f, -1);
    return ra; 
}
int val0[LM], val[LM];
void Solve2(int id, int *a, int *b, int l, int r, int deg)
{
    int ra = r - l + 2;
    if (deg <= 256)
    {
        int F, G;
        for (int i = l; i <= r; i++)
        {
            F = G = 0;
            int u = sta[i], v = 1;
            for (int j = 0; j <= deg; j++)
            {
                F = (F + 1ll * v * a[j]) % MOD;
                G = (G + 1ll * v * b[j]) % MOD;
                v = 1ll * v * u % MOD;
            }
            val0[i] = F, val[i] = G;
        }
        return;
    }
    int mid = l + r >> 1;
    int r1 = Get_mod(a, deg, p[id], ra, a + deg); a += deg;
    int r2 = Get_mod(b, deg, p[id], ra, b + deg); b += deg;
    ra = min(r1, r2);
    Solve2(id << 1, a, b, l, mid, ra), Solve2(id << 1 | 1, a, b, mid + 1, r, ra);
}
int g[MAXN], h[MAXN];
int main()
{
    n = read(), m = read();
    Sum = 0;
    for (int i = 1; i <= n; i++)
        x[i] = read() % MOD, Sum = (Sum + x[i]) % MOD;
    int A = 1, B = 0, C = 0, D = 1;
    for (int i = 1; i <= m; i++)
    {
        if (read() == 1)
        {
            int v = read() % MOD;
            A = (A + 1ll * v * B % MOD) % MOD;
            C = (C + 1ll * v * D % MOD) % MOD;
            insert(A, B, C, D, i);
        }
        else
        {
            swap(A, B);
            swap(C, D);
            insert(A, B, C, D, i);
        }
    }
    if (cnt)
    {
        for (int i = 1; i <= cnt; i++) sta[i] = s[i].g;
        sort(sta + 1, sta + cnt + 1);
        int lenth = unique(sta + 1, sta + cnt + 1) - sta - 1;
        for (int i = 1; i <= cnt; i++)
            s[i].g = lower_bound(sta + 1, sta + lenth + 1, s[i].g) - sta;
        Solve0(g, 1, n);
        for (int i = 1; i <= n; i++) h[i - 1] = 1ll * g[i] * i % MOD;
        Solve1(1, 1, lenth);
        Solve2(1, g, h, 1, lenth, n + 1);
        for (int i = 1; i <= cnt; i++)
            ans[s[i].id] = (1ll * s[i].e * n % MOD + 1ll * s[i].f * val[s[i].g] % MOD * pow_mod(val0[s[i].g], MOD - 2) % MOD) % MOD;
    }
    for (int i = 1; i <= m; i++)
        printf ("%d\n", ans[i]);
    // while (1);
}

高斯消元

long long gauss(int n)
{
    long long ans = 1;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            a[i][j] = (a[i][j] + MOD) % MOD;
    for (int i = 1; i <= n; i++)
    {
        for (int j = i + 1; j <= n; j++)
            while (a[j][i])
            {
                int t = a[i][i] / a[j][i];
                for (int k = i; k <= n; k++)
                {
                    a[i][k] = (a[i][k] - a[j][k] * t % MOD + MOD) % MOD;
                    swap(a[i][k], a[j][k]);
                }
                ans = (MOD - ans) % MOD;
            }
        ans = ans * a[i][i] % MOD;
    }
    return ans;
}



void gauss() {
  int im, num = 1;
  for (int k = 1; k <= n; k++, num++) {
    im = k;
    for (int i = k + 1; i <= n; i++) {
      if (fabs(a[i][k]) > fabs(a[im][k])) i = im;
    }
    if (im != k) {
      for (int i = k; i <= n + 1; i++) swap(a[num][i], a[im][i]);
    }
    if (!a[num][k]) {
      num--;
      continue;
    }
    for (int i = num + 1; i <= n; i++) {
      if (!a[num][k]) continue;
      long double t = a[i][k] / a[num][k];
      for (int j = k; j <= n + 1; j++) {
        a[i][j] -= t * a[k][j];
      }
    }
  }
  for (int i = n; i >= 1; i--) {
    for (int j = n; j >= i + 1; j--) {
      a[i][n + 1] -= a[i][j] * x[j];
    }
    x[i] = a[i][n + 1] / a[i][i];
    sum += x[i];
  }
}

BSGS&exBSGS

int pow_mod(int a, int b, int c)
{
    int ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % c;
        b >>= 1;
        a = a * a % c;
    }
    return ans;
}
struct Hash_Table
{
    struct edge
    {
        int next, x, ans;
    }v[100005];
    int first[76545], p;
    int &operator[](int x)
    {
        int H = x % 76543;
        for (int i = first[H]; i != -1; i = v[i].next)
            if (v[i].x == x)
                return v[i].ans;
        v[p].x = x;
        v[p].next = first[H];
        first[H] = p++;
        return v[p - 1].ans = 0;
    }
    bool count(int x)
    {
        int H = x % 76543;
        for (int i = first[H]; i != -1; i = v[i].next)
            if (v[i].x == x)
                return 1;
        return 0;
    }
    void clear()
    {
        memset (first, -1, sizeof (first));
        p = 0;
    }
}Hash;
int gcd(int a, int b)
{
    return b == 0 ? a : gcd(b, a % b);
}
int BSGS(int a, int b, int c, int d)
{
    Hash.clear();
    int m = floor(sqrt(c)) + 1;
    for (int i = 0; i <= m; i++)
    {
        // if (!Hash.count(b)) 
        Hash[b] = i;
        b = b * a % c;
    }
    int s = pow_mod(a, m, c);
    for (int i = 1; i <= m; i++)
    {
        d = d * s % c;
        if (Hash.count(d)) return i * m - Hash[d];
    }
    return -1;
}
int exBSGS(int a, int b, int c)
{
    b %= c;
    int s = 1;
    for (int i = !a; i <= 40; i++)
    {
        if (s == b) return i;
        s = s * a % c;
    }
    int cnt = 0, d = 1;
    for (int i; (i = gcd(a, c)) != 1; cnt++)
    {
        if (b % i) return -1;
        b /= i, c /= i;
        d = d * a / i % c;
    }
    int ret = BSGS(a, b, c, d);
    if (ret == -1) return -1;
    return ret + cnt;
}

KMP&EXKMP

long long nxt[MAXN], pre[MAXN], extend[MAXN];
char w[MAXN], t[MAXN];
void KMP(char *s, int n) {
  for (int i = 2, k; i <= n; i++) {
    k = nxt[i - 1];
    while (k && s[i] != s[k + 1]) k = nxt[k];
    if (s[i] == s[k + 1]) nxt[i] = k + 1;
    else nxt[i] = 0;
  }
}
void Get_Extend(char *s, int n) {
  pre[1] = n;
  pre[2] = 1;
  while (s[pre[2]] == s[pre[2] + 1] && pre[2] + 1 <= n) pre[2]++;
  pre[2]--;
  int P_pos = 2;
  for (int i = 3; i <= n; i++) {
    if (pre[i - P_pos + 1] + i < pre[P_pos] + P_pos) pre[i] = pre[i - P_pos + 1];
    else {
      pre[i] = pre[P_pos] + P_pos - i;
      if (pre[i] < 0) pre[i] = 0;
      while (s[pre[i] + 1] == s[pre[i] + i] && i + pre[i] <= n) pre[i]++;
      P_pos = i;
    }
  }
}
void Match(char *s, char *t) {
  int m = strlen(s + 1), n = strlen(t);
  Get_Extend(t, n);
  extend[1] = 1;
  while (s[extend[1]] == t[extend[1]] && extend[1] <= n) extend[1]++;
  extend[1]--;
  int P_pos = 1;
  for (int i = 2; i <= m; i++) {
    if (pre[i - P_pos + 1] + i < extend[P_pos] + P_pos) extend[i] = pre[i - P_pos + 1];
    else {
      extend[i] = P_pos + extend[P_pos] - i;
      if (extend[i] < 0) extend[i] = 0;
      while (t[extend[i] + 1] == s[i + extend[i]] && i + extend[i] <= m && extend[i] <= n) extend[i]++;
      P_pos = i;
    }
  }
}

线性筛

const int MAXN = 50000;
int prime[MAXN + 2], mu[MAXN + 2], Sum_mu[MAXN + 2], d[MAXN + 2], e[MAXN + 2], cnt;
long long Sum_d[MAXN + 2];
bool isnprime[MAXN + 2];
void Get_d()
{
    mu[1] = 1, d[1] = 1, isnprime[1] = 1;
    for (int i = 2; i <= MAXN; i++)
    {
        if (!isnprime[i])
        {
            prime[++cnt] = i;
            e[i] = 1;
            d[i] = 2;
            mu[i] = -1;
        }
        for (int j = 1; j <= cnt; j++)
        {
            if (i * prime[j] > MAXN) break;
            isnprime[i * prime[j]] = 1;
            if (i % prime[j] == 0)
            {
                mu[i * prime[j]] = 0;
                d[i * prime[j]] = d[i] / (e[i] + 1) * (e[i] + 2);
                e[i * prime[j]] = e[i] + 1; 
                break;
            }
            mu[i * prime[j]] = -mu[i];
            d[i * prime[j]] = d[i] * 2;
            e[i * prime[j]] = 1;
        }
    }
    for (int i = 1; i <= MAXN; i++)
    {
        Sum_mu[i] = Sum_mu[i - 1] + mu[i];
        Sum_d[i] = Sum_d[i - 1] + d[i];
    }
}

杜教筛

#include <bits/stdc++.h>
using namespace std;
struct Hash_Table {
  struct edge {
    long long x;
    int ans, next;
  }v[100005];
  int first[76545], p;
  Hash_Table() {
    memset (first, -1, sizeof (first));
    p = 0;
  }
  int &operator[] (const long long &x) {
    int H = x % 76543;
    for (int i = first[H]; i != -1; i = v[i].next) {
      if (v[i].x == x)
        return v[i].ans;
    }
    v[p].x= x;
    v[p].next = first[H];
    first[H] = p++;
    return v[p - 1].ans = 0;
  }
  bool count(const long long &x) {
    int H = x % 76543;
    for (int i = first[H]; i != -1; i = v[i].next) {
      if (v[i].x == x)
        return 1;
    }
    return 0;
  }
}mp;
const int MAXN = 1e6;
bool isnprime[MAXN + 5];
int mu[MAXN + 5], prime[MAXN + 5], cnt;
void Get_Prime() {
  mu[1] = 1, isnprime[1] = 1;
  for (int i = 2; i <= MAXN; i++) {
    if (!isnprime[i]) prime[++cnt] = i, mu[i] = -1;
    for (int j = 1; j <= cnt; j++) {
      if (i * prime[j] > MAXN) break;
      isnprime[i * prime[j]] = 1;
      if (i % prime[j] == 0) {
        mu[i * prime[j]] = 0;
        break;
      } else {
        mu[i * prime[j]] = -mu[i];
      }
    }
  }
  for (int i = 1; i <= MAXN; i++)
    mu[i] += mu[i - 1];
}
int Mu(long long x) {
  if (x <= MAXN) return mu[x];
  if (mp.count(x)) return mp[x];
  int &ans = mp[x] = 1;
  long long nxt = 1;
  for (long long i = 2; i <= x; i = nxt + 1) {
    nxt = x / (x / i);
    ans -= (nxt - i + 1) * Mu(x / i);
  }
  return ans;
}
int main() {
  Get_Prime();
  long long a, b;
  cin >> a >> b;
  cout << Mu(b) - Mu(a - 1) << endl;
}

Miller_Robin

long long tmp[100];
int tot;
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
long long mul(long long a, long long b, long long z) {
  return (a * b - (long long)(((long double)a * b + 0.5) / (long double)z) * z + z) % z;
}
long long pow_mod(long long a, long long b, long long p) {
  a %= p;
  long long ans = 1;
  while (b) {
    if (b & 1) ans = mul(ans, a, p);
    b >>= 1;
    a = mul(a, a, p);
  }
  return ans;
}
bool Miller_Rabin(long long x) {
  if (x == 1) return 0;
  for (int i = 0; i <= 9; ++i) {
    if (x == prime[i]) return 1;
    if (x % prime[i] == 0) return 0;
  }
  long long y = x - 1;
  int k = 0;
  for (; !(y & 1); y >>= 1) k++;
  for (int i = 0; i < 10; ++i) {
    long long z = rand() % (x - 1) + 1;
    long long c = pow_mod(z, y, x), d;
    for (int j = 0; j < k; ++j, c = d)
      if ((d = mul(c, c, x)) == 1 && c != 1 && c != x - 1)
        return 0;
    if (d != 1) return 0;
  }
  return 1;
}
long long Pollard_Rho(long long x, int y) {
  long long i = 1, k = 2, c = rand() % (x - 1) + 1;
  long long d = c;
  while (1) {
    i++;
    c = (mul(c, c, x) + y) % x;
    long long g = __gcd((d - c + x) % x, x);
    if (g != 1 && g != x) return g;
    if (c == d) return x;
    if (i == k) d = c, k <<= 1;
  }
}
void Divide(long long x, int c) {
  if (x == 1) return;
  if (Miller_Rabin(x)) return tmp[++tot] = x, void();
  long long z = x, tp = c;
  while (z >= x) z = Pollard_Rho(z, c--);
  Divide(z, tp), Divide(x / z, tp);
}

小米手环3 NFC 体验

Mon, 17 Jun 2019 14:04:09 GMT

前言

昨天在网上看到手环3打折了，而且我也不想要手环4.
所以就立刻下单买了个小米手环3NFC 版，今天早上就送到了。

然后就是立即打开包装

好像没电。。。

先充电，充电的时候顺便用手机更新了一下。
一切OK 感觉还不错（蓝色是照片的缘故）。

然后就是用了，心率挺准。
其他的还没测。
以后再也不用担心走路没带手机记不上步了 :) 。

【NOI2017】游戏 2-SAT

Fri, 29 Jun 2018 08:02:09 GMT

题目描述

小 L 计划进行 $n$ 场游戏，每场游戏使用一张地图，小 L 会选择一辆车在该地图上完成游戏。

小 L 的赛车有三辆，分别用大写字母 $A$、$B$、$C$ 表示。地图一共有四种，分别用小写字母 $x$、$a$、$b$、$c$ 表示。

其中，赛车 $A$ 不适合在地图 $a$ 上使用，赛车 $B$ 不适合在地图 $b$ 上使用，赛车 $C$ 不适合在地图 $c$ 上使用，而地图 $x$ 则适合所有赛车参加。

适合所有赛车参加的地图并不多见，最多只会有 $d$ 张。

$n$ 场游戏的地图可以用一个小写字母组成的字符串描述。例如：$S=\texttt{xaabxcbc}$ 表示小L计划进行 $8$ 场游戏，其中第 $1$ 场和第 $5$ 场的地图类型是 $x$，适合所有赛车，第 $2$场和第 $3$ 场的地图是 $a$，不适合赛车 $A$，第 $4$ 场和第 $7$ 场的地图是 $b$，不适合赛车 $B$，第 $6$ 场和第 $8$ 场的地图是 $c$，不适合赛车 $C$。

小 L 对游戏有一些特殊的要求，这些要求可以用四元组 $ (i, h_i, j, h_j) $ 来描述，表示若在第 $i$ 场使用型号为 $h_i$ 的车子，则第 $j$ 场游戏要使用型号为 $h_j$ 的车子。

你能帮小 L 选择每场游戏使用的赛车吗？如果有多种方案，输出任意一种方案。

如果无解，输出 -1。

输入格式

输入第一行包含两个非负整数 $n$, $d$。

输入第二行为一个字符串 $S$。

$n$, $d$, $S$ 的含义见题目描述，其中 $S$ 包含 $n$ 个字符，且其中恰好 $d$ 个为小写字母 $x$。

输入第三行为一个正整数 $m$ ，表示有 $m$ 条用车规则。

接下来 $m$ 行，每行包含一个四元组 $i,h_i,j,h_j$ ，其中 $i,j$ 为整数，$h_i,h_j$ 为字符 $A$ 、$B$ 或 $C$，含义见题目描述。

输出格式

输出一行。

若无解输出 -1。

样例

样例输入

3 1
xcc
1
1 A 2 B

样例输出

ABA

小 $L$ 计划进行 $3$ 场游戏，其中第 $1$ 场的地图类型是 $x$，适合所有赛车，第 $2$ 场和第 $3$ 场的地图是 $c$，不适合赛车 $C$。

小 $L$ 希望：若第 $1$ 场游戏使用赛车 $A$，则第 $2$ 场游戏使用赛车 $B$。

那么为这 $3$ 场游戏分别安排赛车 $A$、$B$、$A$ 可以满足所有条件。

若依次为 $3$ 场游戏安排赛车为 $BBB$ 或 $BAA$ 时，也可以满足所有条件，也被视为正确答案。

但依次安排赛车为 $AAB$ 或 $ABC$ 时，因为不能满足所有条件，所以不被视为正确答案。

数据范围与提示

题解

2-SAT

上来看这到题。
感到 $a,b,c$ 的时候很好搞，但是不知道 $x$ 怎么办。
$a, b, c$ 的时候是2-SAT，那 $x$ 不就是 3-SAT 了么。
这是NPC问题啊。

之后看来一下数据范围， $x \le 8$ 发现 $x$ 可以枚举。然后就是一个裸的2-SAT了。

2-SAT 输出方案

Tarjan

Tarjan缩点时会给联通块编号

对于一对相互对立的问题，谁的新编号小就选谁。

简单清真，不用去跑什么 反图+拓扑排序 了。

#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
const int MAXN = 50005;
const int MAXM = 100005;
struct data {
  int i, hi, j, hj;
} D[MAXM];
struct edge {
  int END, next;
} v[MAXM << 2];
int first[MAXN << 1], p;
void add(int a, int b) {
  v[p].END = b;
  v[p].next = first[a];
  first[a] = p++;
}
char tmp[2][5];
char S[MAXN];
int id[10];
int ID(int x, int y) {
  if (S[x] - 'a' == y) return 0;
  if (S[x] == 'a') return x * 2 + y - 1;
  else if (S[x] == 'b') return x * 2 + y / 2;
  else return x * 2 + y;
}
int dfn[MAXN << 1], low[MAXN << 1], Index, belong[MAXN << 1], T;
bool vis[MAXN << 1];
int st[MAXN << 1], top;
void Tarjan(int rt) {
  dfn[rt] = low[rt] = ++Index;
  st[++top] = rt;
  vis[rt] = 1;
  for (int i = first[rt]; i != -1; i = v[i].next) {
    if (!dfn[v[i].END]) {
      Tarjan(v[i].END);
      low[rt] = min(low[rt], low[v[i].END]);
    } else if (vis[v[i].END])
      low[rt] = min(low[rt], dfn[v[i].END]);
  }
  if (low[rt] == dfn[rt]) {
    T++;
    int x;
    do {
      x = st[top--];
      vis[x] = 0;
      belong[x] = T;
    } while (low[x] != dfn[x]);
  }
}
bool Calc(int n, int m) {
  memset(first, -1, sizeof(first)), p = 0;
  memset(dfn, 0, sizeof(dfn));
  memset(low, 0, sizeof(low));
  memset(belong, 0, sizeof(belong));
  T = Index = 0;
  for (int i = 1; i <= m; ++i) {
    int t1 = ID(D[i].i, D[i].hi);
    int t2 = ID(D[i].j, D[i].hj);
    if (t1) {
      if (t2) add(t1, t2), add(t2 ^ 1, t1 ^ 1);
      else add(t1, t1 ^ 1);
    }
  }
  for (int i = 2; i <= 2 * n + 1; ++i) {
    if (!dfn[i]) Tarjan(i);
    if (i & 1) {
      if (belong[i] == belong[i - 1]) return 0;
    }
  }
  for (int i = 1; i <= n; ++i) {
    if (belong[2 * i] < belong[2 * i + 1]) {
      if (S[i] == 'a') printf("B");
      if (S[i] == 'b') printf("A");
      if (S[i] == 'c') printf("A");
    } else {
      if (S[i] == 'a') printf("C");
      if (S[i] == 'b') printf("C");
      if (S[i] == 'c') printf("B");
    }
  }
  printf("\n");
  return 1;
}
int main() {
  int n = read(), d = read();
  scanf("%s", S + 1);
  int x = 0;
  int m = read();
  for (int i = 1; i <= m; ++i) {
    scanf("%d%s%d%s", &D[i].i, tmp[0], &D[i].j, tmp[1]);
    D[i].hi = tmp[0][0] - 'A';
    D[i].hj = tmp[1][0] - 'A';
  }
  for (int i = 1; i <= n; ++i)
    if (S[i] == 'x') id[++x] = i;
  int N = (1 << d) + 1;
  for (int i = 0; i <= N; ++i) {
    for (int j = 1; j <= x; ++j)
      if (i & (1 << (j - 1))) S[id[j]] = 'a';
      else S[id[j]] = 'b';
    if (Calc(n, m)) return 0;
  }
  return printf("-1\n"), 0;
}

清北夏令营前集训日记

Wed, 16 May 2018 19:37:10 GMT

2018-5-16

才发现今天距离我开坑 APIO&&CTSC集训日记刚好一个月。
上午考试
上来先通读了一边题目，发现$T2$好像是原题，然后简单的想了一下$T1$和$T3$，发现没有$T2$好做。
于是先打$T2$。半个小时打完了$T2$。
之后发现$T3$的$40$分暴力好像还是比较好打。然后先打了一个$O(2^{n}nL)$的，然后写了一个暴力和他拍打。完这些之后想了一下$T3$的正解，发现我并不会把复杂度降到指数以下，这时已经9点半了。
最后去写$T1$。可能我的打法比较傻，暴力打起来并不是很简单，用了一个多小时的时间才把暴力调出来。
然后想到了一个线段树的乱搞做法，然后就开始搞，结果到最后也没调出来。
没有挂分，只是$T1$暴力用的时间有点多，导致没有拿到$T1$的高分暴力。下午改完题，看了一下清华校赛的题，把考场上想做但是没有做出来的题看了一下，发现正解很简单，还是太弱了。

2018-5-17

今天是ACM
上来先通读了题目。花了不到$20$分钟就看完了题而且对每个题的难度有了一个初步的评估。
$D$题一定是最先做的，可以看出来这是一道签到题。只要一个简单的$Hash$就能解决。在开场半小时就切出了这道题。
看有人$A$掉了$C$题，虽然感觉是数据有问题但还是去做了，开始打，打到一半发现重测了，这时只有一个人过了，想了一种新的做法，开始重新打，打完这种做法之后感觉过不了，先没有交。
看了一下其他的题，看了一圈之后感觉E题和G题稍微有点思路。
然后上了个厕所，发现C题可以优化到$ O(n\ln(n))$ 先交了一发暴力，发现真的过不了，改正解，交上去发现$WA$了，又改了改，还是$WA$，突然发现要输出 Case #x: 加上就过了。之后去打$G$，先有梦想的打了一个网络流，交上去果然$T$了，接下来打我心目中的正解，打到一半发现好像不是那没么好打，看了一下时间，和我接下来要写的代码量，果断的弃了这道题。到考试结束也没想出其他题。

下午发现好像$E$最可改（虽然事实证明这是假的）。改了一下午还是没过，卡常啊。。。。。
晚上又优化了一波常数才过，然后改了 $F$。还想改 $G$, 不过还没改。

2018-5-18

考试
上来先看了一边题，然后发现都不怎么会，看出来$T2$是一道原题，但是原题的数据范围在这道题中只有$30$分。
先打了一个$30$分，然后看$T1$和$T3$，想了想，并没有想出来，先打了$T3$， $T1$ 两个有梦想的暴力，然后并没有分。
尝试去想正解，无果，看到$T3$ 的数据范围是$10^{7}$, 感觉很慌，还是没想出正解。
下来发现$T2$的$30$分并没有拿到，被卡了常数，卡了好久才过， $T3$是最可做的，我没看出了他是一颗树。改题
T3很好改。
T2打出了一个DFS的打法过了。
T1最不可改，还没有改出来。

2018-5-20

昨天沉迷改题无法自拔。
今天考试
上来先看了一遍题，发现都没有什么思路。
发现T3是一道提答，然后先玩了一会儿提答，把前4个点跑了出来。然后回头看T1打了一个20分的DP，然而并不会优化了。
去看T2，转换为图论，好像是一个子完全图类似的东西。
然而并不会了。
在回头看T3跑了一下5～8, 又得了一点分。
也就拿到这么多分了。
不过今天的题还是比较好改的。

2018-5-21

今天把PKUWC的题做了一下。
下午考了一个学考，晚上回来继续做题，然后背了一会儿政治，一天就这样过去了。

2018-5-23

这两天没考试，就没怎么写。
今天做了不少UOJ的题，虽然都不是什么难题，但是锻炼一下思维么。
今天终于把旷野大计算过了，非常开心。

2018-5-24

今天IOI赛制。
上来先看T1，第一眼以为是四维偏序，打了个 CDQ+BIT+Seg_Tree ，然后发现样例不对，再一看题，发现其实是三维偏序，把 Seg_Tree 删掉然后测大样例死活不对，浪费了我好长时间，最后发现大样例是错的。
然后打了一个$T3$的暴力，打了一个T2的暴力，然后打了T3的乱搞， T3骗了不少分。

2018-5-25

上来先看T1发现好像会60分，就打了。
T2只会直接输出的20分， T3打了一个爆搜。
结果T1是一道FST好题，出了成绩才发现自己想的是错的。
T3的暴力也不知道出现了什么问题。
总之这道题打的不是很好。
主要是暴力没有打好，没有拿到应该拿的分数。

2018-5-26

忘写了

2018-5-27

今天没有考试。
主要把前几天没改完的题改了一下。
然后做了一道UOJ的水题。

2018-5-28

今天考了一场试。
去了东师大附的OJ 考的不是很好，原因是我没能静下心来。这次考试让我找到了我在考场上的状态，十分的紧张。
其实我很需要这种状态的训练。
这种情况下如何静下心来思考是我的一大问题。如果能解决，那就能提升自己的水平了。
然后把清华的回执给填了。

2018-5-29

和昨天一样不过我考了OI赛制，感觉OI赛制没有IOI那么慌。
上来先看T1，想了很多种做法，但是都不是很对，最后只能打一个40分的做法。
然后是T2先打了一个暴力，但是不对，想不出来为什么？？？最后也没有得到分，后来知道是因为少考虑了一种情况。
T3是一道见过但是不会做的神题答。
只那了可以手玩儿出来的一点分，然后回去想T2，也没想出来为什么没分。

2018-5-30

才发现时间都是错的。。。还是IOI与OI同时考，上来第一题想了一个40分的DP，去看T2推了好久通项，最后推出了一点东西，但是没有什么用，打了一个60分的矩阵乘。
然后看T3，一直想K<=5的怎么做，最后没想出来，然后打了一个Q<=10的和链上的部分分。

2018-5-31

考试。
T1考场上写了一个38分的暴力，然后想到了52分特征多项式可以跑过去，但是我不是很会特征多项式，于是只能GG了。
T3是真的一点都不会，只好去玩T2的提答，发现前三个点都是比较好打的。然后第四个点，先手玩儿了一会儿，发现做不出来，打了一个模拟退火就过了，然后第5个点还是退火，不过没有多少分，后面的点只能有一个保底分了。

去北大的开始收拾东西了。我们也帮着收拾了一下。

2018-6-1

考试，改题。
今天只有4个人。。
好像没什么事了，不过今天得回去收拾东西。

APIO && CTSC 完结

Tue, 15 May 2018 07:32:39 GMT

结束了

从来到北京到今天，已经过去了快 10 天了。
我也是需要总结一下这几天。

先从考试来说吧，这几次考试教会了我很多，因为我都死在了 T1 上。
CTSC 中 Day1 没有去想本身很简单的第一题。而是花费了太多的时间在其他两题上，使我没有得到我有能力拿到的分数。
而 APIO 更是如此，不过这次恰恰相反。因为我花费了太多的时间在 T1 上， T2 和 T3 都没有去想，甚至都没有仔细看一下部分分，导致 T3 这道最好拿分的一道题没有拿更多的分。

这两次的问题，主要是出在对题目难度的把控上。
虽然通读了题面，但是我却并没有对哪道题好得分，哪道题不好得分有清晰的认识，我可以确定，这是考试经验不足和题量少的缘故。

还有一个突出的问题，是速度——打题的速度。
很多时候在脑海中已经想好的解法却没有充足的时间去实现。
而在写代码的时候也会卡壳，不知道该打什么，这其实是思路不清晰的缘故。

这两次比赛，让我看到了差距，也确定了接下来一段时间努力的方向。

知识是一方面，心态更是一方面。

在做题的时候，没有一种能做出题的自信，这是一个很大的问题，这种自信的缺乏使得我少了不少动力去继续深入的思考。

接着是清华校赛，这场比赛让我对细心这两个字有了更深入的了解: 一个 2148473648 的模数与 2147483678 有着本质的区别，如果想当然的话，那会浪费你宝贵的时间。

这些天我得到了什么？我得到了我突出的几个问题，这是我下一步改进的方向。

还有 2 个月就要 NOI 了，加油吧。

UOJ328 【UTR #3】量子破碎

Sat, 21 Apr 2018 15:12:31 GMT

Scape下载了好久终于下完了关于量子巧克力的游戏——Quantum break，准备邀请Mythological来享受在一起的时光。可是谁知道积劳成疾的Scape，居然在Mythological到来之前就陷入了梦境之中。

Scape在梦境中隐隐约约看见了这样的一份题面：

Mythological应邀来和他一起隔膜，并且带来了一盒与游戏中同款的 ”黎明前就会破碎的量子巧克力“。

在游戏里量子巧克力可以看做一个数组 $a$，长度为 $2^n$，下标从 $0$ 开始到 $2^{n}-1$ 结束。

他们俩可以关于这些量子巧克力，向游戏做一些询问，但是不幸有的询问会导致量子破碎，此时游戏会刷新这个数组开始新的一轮....

即使是在梦中，Scape也想让Mythological开心，请你帮一帮他。

任务

每轮游戏开始的时候数组里只有 $a[x]=a[y]= \frac{1}{\sqrt{2} }$（$x \neq y$），剩下的元素都是 $0$。

你需要编写一个函数和交互库进行多轮交互，求出 $x \oplus y$ 的值（每轮中 $x \oplus y$ 不变）:

query_xor(n, t);
- n 表示 a 的长度是 $2^n$，t 表示子任务编号。
- 你的返回值是 $x \oplus y$ 的答案。

你可以通过四种操作来确定这个值:

query();
- 向交互库做一次询问。
- 交互库会随机返回一个下标，具体来说返回 $x$ 的概率恰好是 $\frac{a[x]^2}{\sum_i a[i]^2}$。
- 返回 $x$ 之后，会开始新的一轮，交互库重新随机一对 $x$ 和 $y$ 保证 $x \oplus y$ 不变（在所有满足条件的 $x,y$ 中等概率随机，有可能不变），然后重新给数组 $a$ 赋值，使得数组里只有 $a[x]=a[y]=\frac{1}{\sqrt{2} }$ ($x \ne y$)，剩下的元素都是 $0$。
manipulate(A, i);
- 向交互库做一次操作，给出一个 $2 \times 2$ 的实数矩阵 $A$。
- 交互库会把数组 $a$ 更新，具体来说，对于每个二进制第 $i$（$i$ 是传入的参数）位为 $0$ 的数 $x$，令$$ \begin{cases} b[x] = A[0][0] \cdot a[x] + A[1][0]\cdot a[x+2^i],\ b[x+2^i] = A[0][1]\cdot a[x] + A[1][1]\cdot a[x+2^i],\end{cases} $$ 则 $a[x]$ 将更新为 $b[x]$, $a[x+2^i]$ 将更新为 $b[x+2^i]$。
- 为了保证 $a[x]^2$ 的和 (概率和) 始终为1, 你的矩阵必须满足$AA^T=I$, 可以证明此时 $a[x]^2$ 的和始终不变（$A^T$ 表示 $A$ 的转置，$I$ 为单位矩阵）。
arbitary_manipulate(A, i);
- 和 manipulate 不同的是，这里不强制 $AA^T=I$。
- 使用了这个函数后，$\sum a[x]^2$ 可能不为 $1$，询问的时候概率按照 $a[x]^2$ 的比例平均分配。
- 如果 $\sum a[x]^2 = 0$，交互库会返回 0。（请选手使用下发的 grader 判断自己程序的精度问题）
arbitary_query(x);
- 询问 a[x] 为多少。
- 和 query 不同，不会导致数组清空开始新的一轮。

限制与约定

一共五个子任务，每个子任务有对应的分数。

每个子任务都有对应的可以使用的函数，使用了不可使用的函数会失去这个子任务的分数。

为了拿到每个子任务的分数，你必须通过所有他依赖的子任务。

所有的子任务中都不能使用超过 $400$ 个操作。

子任务	分值	$n$ 的规模	可以使用的函数	依赖的子任务
1	5	$n=8$	1,2,3,4
2	15	$n=16$	1,2,3,4	1
3	20	$n=16$	1,2,3	1,2
4	20	$n=16$	1,2,4	1,2
5	20	$n=6$	1,2
6	20	$n=16$	1,2	1,2,3,4,5

时间限制：$2s$ 空间限制：256MB

UOJ328

题解

Subtask 1

我们看到 $n$ 较小，我们可以直接查询每一个位置，然后就获得了 $5$ 分的好成绩。

5pts

Subtask 2

因为每个函数只能用小于 $400$ 次，我们考虑如何减少查询次数。

按位考虑
如果我们只想知道 $x \oplus y$ 的第 $i$ 位是否为$1$，那么我们不用考虑其他位，也就是说，我们要把 $x,y$ 中除第 $i$ 位以外的位都变为 $0$。这是一个不可逆的操作。所以矩阵是不可逆的，所以我们要用的操作为 $3$, 矩阵为 $\begin{pmatrix} 1 & 1 \ 0 & 0 \end{pmatrix}$
这本质上是把第 $i$ 位为 1 的数 $x$ 累加到 $x - 2^i$ 上，然后将 $x$ 的值设为 $0$。
最后要查询一下 $a[0]$ 与 $a[2^i]$ 是否都为 $1$。

20pts

(UPD 2018-4-25 21:37)
还有一种方法(by wq)
同样是按位考虑作用矩阵 $\begin{pmatrix} 1 & 1 \ 0 & 1 \end{pmatrix}$
这样作用完了之后如果 $x \oplus y$ 中有 $2^i$，那么最后查询 $2^i$就为$\frac{1}{\sqrt{2} }$。
查询一下就好了。
20pts

Subtask 3

Part1

我们考虑如何丢掉最后一步用操作4查 $a[0]$ 和$a[2^i]$
如果直接随机，那么无论 xor 是 0 还是 1 ，都会随机返回 0 或 1 （每次 x 会重新随机）。
为了区分出来我们做变换 $a[0]=a[0]+a[2^i]$, $a[2^i]=a[0]-a[2^i]$, 用上矩阵$\begin{pmatrix} 1 & 1 \ 1 & -1 \end{pmatrix}$
如果异或值为 1 则答案一定为 $0$, 否则答案为$0$或$1$。那么我们可以多次询问搞一下。

可是并不能过掉第三个Subtask，因为复杂度是 $n^2$ 的然后如果乘个常数，好像就超次数了。
如果我的理解有不对的，请联系我。

Part2

我们考虑另一种概率做法。注意题面里有提到交互库的实现，会在概率平方和为0的时候返回0。
如果平方和不为0，返回0的概率很小。
对于每一位我们作用上 $\begin{pmatrix} 1 & 0 \ 0 & 0 \end{pmatrix}$
这样如果 $x, y$ 的第 $i$ 位都为 1，则一定会返回 $0$, 其他情况下返回$0$ 的概率很小，基本不用考虑。
那么如果返回 $0$，我们可以就认为$x, y$的第$i$ 位都为 1。这种方法得出的结果是有很小的概率不对的，但正确的概率很大。事实上, 所有 Subtask 3 的数据都不会卡掉这个做法。但如果 $x, y$ 的值都为 $0$, 他依然不会返回 $0$, 所以我们要多次查询，在这些次中，有很大的概率使得有至少一次 $x, y$ 都为 1。

到此我们得到了 $40$ 分的好成绩。

40pts

Subtask 4

我们看一下Subtask 3 Part1 中的那个变换，其实它很有用。
他本质上就是一个异或的$FWT$的正变换。
然后回顾一下他的性质，在变换完的数组中，下标为 $2^i$ 的位置的值为所有二进制中第 i 位不为 1 的数的和减所有二进制中第 i 位为 1 的数的和。
那么如果 $x, y$ 的二进制第 $i$ 位相同那么 $a[2^i]$ 就是 0，反之亦然。
这样我们就能求出答案了

还有一件事，因为要保证 $AA^T=I$，所以我们不能用 $\begin{pmatrix} 1 & 1 \ 1 & -1 \end{pmatrix}$ 而是用 $\begin{pmatrix} \frac{1}{\sqrt{2} } & \frac{1}{\sqrt{2} } \ \frac{1}{\sqrt{2} } & -\frac{1}{\sqrt{2} } \end{pmatrix}$
这样相当于将所以数都乘了一个 $\frac{1}{\sqrt{2} }^n$ 这样就有 $60$ 分了。

60pts

Subtask 5 & 6

我们已经知道了他是一个$FWT$，我们考虑随机的一位对我们有用的信息是什么

考虑 $x$ 对一个数 $t$ 的贡献，根据 $FWT$ 的定义他显然为 $(-1)^{cnt(x & t)}$， $cnt(x & t)$ 表示 $x & t$ 的二进制中 1 的个数。
如果有两个数 $x, y$ 对 $t$ 贡献，那么贡献的值 $v$ 为 $(-1)^{cnt(x&t)} + (-1)^{cnt(y & t)}$
$v$ 不为 0 的条件是 $cnt(x & t) + cnt(y & t)$ 为奇数。
我们可以证明 $cnt(x & t) + cnt(y & t)$ 的奇偶性与 $cnt((x \oplus y) & t)$ 的奇偶性相同。
证明:

考虑没一个二进制位。
枚举 $x, y, t$ 在这一位的值，在每一种情况下他们的奇偶性相同

$x$ $y$ $t$ $cnt(x & t) + cnt(y & t)$ $x \oplus y$ $cnt((x \oplus y) & t)$

0 0 0 0 0 0

0 0 1 0 0 0

0 1 0 0 0 0

0 1 1 1 1 1

1 0 0 0 0 0

1 0 1 0 0 0

1 1 0 1 1 1

1 1 1 2 0 0

$x$	$y$	$t$	$cnt(x & t) + cnt(y & t)$	$x \oplus y$	$cnt((x \oplus y) & t)$
0	0	0	0	0	0
0	0	1	0	0	0
0	1	0	0	0	0
0	1	1	1	1	1
1	0	0	0	0	0
1	0	1	0	0	0
1	1	0	1	1	1
1	1	1	2	0	0

我们可以求出任意 $n$ 个不为 0 的位置。如果他们是线性无关的，那是不是就能求出 $x \oplus y$ 的值了呢？

很可惜并不是。这些 $t$ 可能并不是满秩的！
因为所有 $x \oplus y = 0$ 始终都会是 xor 方程的解。

那怎么办呢？

有两种方法
枚举每一个不为 0 的数。判断他是否为这个方程的解。
时间复杂度为 $O(n2^n)$，询问次数为 $O(n^2)$。

或者:
直接高斯消元，然后排除掉 $x \oplus y = 0$ 这个解就可以了。
时间复杂度为 $O(n^2)$, 询问次数为 $O(n^2)$

可以 AC 此题。

~~FWT从入门到放弃~~

#include "quantumbreak.h"
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <vector>
using namespace std;
double q = sqrt(0.5);
double C[2][2] = {{q, q}, {q, -q}};
vector<int> vc;
int Num(unsigned int x)
{
	unsigned int tmp = x
					 - ((x >> 1) & 033333333333)
					 - ((x >> 2) & 011111111111);
	tmp = (tmp + (tmp >> 3)) & 030707070707;
	return tmp % 63;
}
int query_xor(int n, int t)
{
	int ans = 0;
	for (int j = 0; j <= 20; j++)
	{
		for (int i = 0; i < n; i++)
			manipulate(C, i);
		vc.push_back(query());
	}
	// for (auto x : vc)
		// printf ("%d\n", x);
	for (int i = 1; i < (1 << n); i++)
	{
		bool flag = 0;
		for (auto x : vc)
		{
			// if (i == 42163) printf ("%d\n", Num(x & i));
			if (Num(x & i) & 1)
			{
				flag = 1;
				break;
			}
		}
		if (!flag) return i;
	}
	// printf ("%d\n", ans);
	return 0;
}

扩展Lucas定理求组合数

Fri, 20 Apr 2018 08:51:06 GMT

在求组合数的时候，我们可能遇到模数是非质数的情况，这时正常的Lucas可能无法解决问题。所以我们要用到扩展Lucas定理

我们令 $p = p_{1}^{k_{1} } + p_{2}^{k_{2} } + p_{3}^{k_{3} } + \cdots + p_{q}^{k_{q} }$
可得同余方程
$$ \left \lbrace { \begin{array}{c} ans \equiv c_1\pmod { {p_1}^{k_1} } \ ans\equiv c_2\pmod { {p_2}^{k_2} } \ ans\equiv c_2\pmod { {p_2}^{k_2} } \ \ldots \ ans\equiv c_q\pmod { {p_q}^{k_q} } \end{array} } \right.$$

然后我们考虑求 $C_{n}^{m} % p_{i}^{k_{i} }$ 的值
因为 $C_{n}^{m} = \frac{n!}{n!(n - m)!}$
我们只要求出$n! % p_{i}^{k_{i} }$, $m! % p_{i}^{k_{i} }$, $(n - m)! % p_{i}^{k_{i} }$

我们考虑如何求 $x! % p_{i}^{k_{i} }$
以 $x = 19, p_{i} = 2, k_{i}=2$ 为例
$x! = 1 \times 2 \times 3 \times 4 \times 5 \times 6 \times 7 \times 8 \times 9 \times 10 \times 11 \times 12 \times 13 \times 14 \times 15 \times 16 \times 17 \times 18 \times 19$
$= (1 \times 2 \times 4 \times 5 \times 7 \times 8 \times 10 \times 11 \times 13 \times 14 \times 16 \times 17 \times 19) \times (1 \times 2 \times 3 \times 4 \times 5 \times 6) \times 3^6$

求解$n!$可以分为3部分: 第一部分是$p_i$的幂的部分可以直接求解 ${p_i}^{\lfloor{n\over p_i}\rfloor}$
第二部分是一个新的阶乘${\lfloor{n\over p_i}\rfloor}!$
发现第三部分在模$p_{i}^{k_{i} }$意义下是以$p_{i}^{k_{i} }$为周期的然后就可以较轻松的求出了

最后一个问题是对于求出的$m! % p_{i}^{k_{i} }$， $(n - m)! % p_{i}^{k_{i} }$ 有可能与 $p_{i}^{k_{i} }$ 不互质。
我们需要将 $p_{i}^x$ 拆出来考虑就可以了

计算$n!$中质因子$p$的个数$x$的公式为$x=\lfloor{n\over p}\rfloor+\lfloor{n\over p^2}\rfloor+\lfloor{n\over p^3}\rfloor+\ldots$
递推式也可以写为$f(n)=f(\lfloor{n\over p}\rfloor)+\lfloor{n\over p}\rfloor$

pk 为 $p^k$, exP为$p_{i}$ phip 为 $\phi(p^k)$

long long Mul(int n, int id)
{
	if (n == 0) return 1;
	long long ans = 1;
	if (n / pk[id])
	{
		for (int i = 2; i <= pk[id]; i++)
			if (i % exP[id])
				ans = ans * i % pk[id];
		// ans = pow_mod(TT[id][pk[id]], n / pk[id], pk[id]);
	}
	// ans = ans * TT[id][n % pk[id]] % pk[id];
	for (int i = 2; i <= n % pk[id]; i++)
		if (i % exP[id])
			ans = ans * i % pk[id];
	return ans * Mul(n / exP[id], id) % pk[id];
}
int exlucas(int n, int m, int id)
{
	if (n < m || n < 0 || m < 0) return 0;
	if (m == n || m == 0) return 1;
	long long a = Mul(n, id), b = Mul(m, id), c = Mul(n - m, id);
	int t = 0;
	for (int i = n; i; i /= exP[id]) t += i / exP[id];
	for (int i = m; i; i /= exP[id]) t -= i / exP[id];
	for (int i = n - m; i; i /= exP[id]) t -= i / exP[id];
	return a * pow_mod(b, phip[id] - 1, pk[id]) % pk[id] * pow_mod(c, phip[id] - 1, pk[id]) % pk[id] * pow_mod(exP[id], t, pk[id]) % pk[id];
}
long long CRT(int *a, int *b, int n)
{
    long long N = 1, Ni, now, ans = 0;
    for (int i = 1; i <= n; i++) N *= a[i];
    for (int i = 1; i <= n; i++)
    {
        Ni = N / a[i];
        now = pow_mod(Ni, phip[i] - 1, a[i]);
        ans = (ans + (b[i] * now % N) * Ni % N) % N;    
    }
    return ans;
}
long long Calc(int n, int m)
{
	if (n < 0 || m < 0 || n < m) return 0;
	for (int i = 1; i <= t; i++)
	{
		b[i] = exlucas(n, m, i);
	}
	return CRT(pk, b, t);
}

CTSC&APIO前集训日记

Mon, 16 Apr 2018 21:21:21 GMT

2018-4-16

从省选回来的时间不短了
把题改完之后就是在做 $DP$
今天做 $DP$ 和网络流的互相交流了一下
然后呢，就没什么了。
今天做了半天的网络流。

2018-4-17

今天考了一场试，好久没见到这么清真的考试题了
其实都是 LOJ 上的原题，也算是比较好做吧
改完题后继续做网络流的题目，先打了 $UOJ77$ 的 $60$ 分部分分
然后去看正解，用主席树优化建图，看完之后感觉这种方法很是神器，但并不复杂
然后就去做 UOJ217 奇怪的线段树还没有做完。
听说明天换Linux?

2018-4-18

真的换Linux了不过祖传硬盘还是233
然后继续做网络流的题目，用Linux打代码好不方便啊。
没有GIT真伤心，不过听说明天考试，然后网络流就完了。
然后就开数学了。

2018-4-19

考了场试，今天的考试就不是很清真了，
$T1$ 是一道考组合数取模的题目。
$T2$基本上是一个裸的$FWT$加倍增，
$T3$ 是一道$DP$ 打的我很蒙，主要是由三个DP数组互相转移。

不过google输入法真难用。

2018-4-20

一直在做数学。
在UOJ上找了道不错的题目然后开始做， 50分的部分分非常的好想。然后去想100分做法不会啊，勉强看懂了题解，但是丝毫不会实现，去看代码，然后发现根本看不懂代码。。。
就对着代码一行一行的看，一点一点的理解，然后发现这好像是就一个洲阁筛。回头看题解，发现推导过程与洲阁筛一样。
可是我也不会洲阁筛啊然后只好先简单学习了一下洲阁筛，勉强看懂了代码。
然后一天就快要过去了
晚上打了「WC2018」州区划分发现其实50分非常好打啊。为什么我当时不会啊。

2018-4-21

基本上一天都是在 $FWT$ 上午先做了两道简单的题，然后开始做UOJ328 【UTR #3】量子破碎, 这是一道 $FWT$ 好题，刚看到的时候我以为是一道人类智慧题，就是瞎构造一些矩阵往上搞。
然后并没有搞出来，最后正解居然是 $FWT$ 很震惊。
做了一下午加一晚上。。

2018-4-22

考试，改题，这题解是假的吧。。。

2018-4-23

考试改题，暂时弃掉了 T2 去改昨天的 $T3$。
还是没调出来啊。
估计是调不出来了。。。

2018-4-24

听说今天的题很正常？？？？？？？？？？？？？

怎么可能呢！！！！！！！

$T2$ 还是很可改的。
然而$T1$卡了我一波内存。
不知道为什么重载new 就过了。
$T3$ 一点都不会，还没有看呢。。 UPD(2018-4-25): $T3$ 好像不难，主要是先得到一些关键性的性质定义好方程然后转移就可以了。
在最后手解一下方程组。

2018-4-25

改完了昨天的题。
把明天大家要交流的题都看了一遍。
没了。

2018-4-26

上午互相交流了一下题目。
用了整整一个上午的时间。
下午突然老师说要考试，极奇疲惫。
考到一半感觉到头疼。
晚上改题。 $T1$ 是一道假题。
不想写了。

2018-4-28

断了一天啊，昨天忘写了。
今天考试一看 $T1$ 感觉还是很可做的。
推了一会儿也退出来了，然而因为少了一个细节而少了 $20$ 分。
$T2$ 一眼就能看出 $30$ 分，两眼就能看出 $50$ 分然后就不会了。
$T3$ 看出了 $60$ 分的打法，然后时间不够没有打完。
以后要更加合理的分配时间，简单题要考虑好代码的细节。
另外打代码要快一点，不能想出来没打完。

2018-4-30

29号放了一天假，回去休息了一下。
今天下午来学校主要是把昨天的题改了。
$T1$ 是一道一眼就能看出正解的题目，可是出题人却让输出分数，然后精度就很迷。
$T2$ 是一道并不是很难的 $DP$，至少对与 $40$ 分是这样的。然后对于再高的分数，就要有一个非常巧妙的的转换。
$T3$ 是一道简单清真小 $DP$， $50$ 分就是一眼，然后满分也是一个不能的 $DP$, 就是需要分奇偶讨论一下，有一点烦。
今天晚上有点困啊。

2018-5-1

劳动节，真是劳动。
数据结构专题。。。
不想说什么了，气死了。
打完一个200多行的代码还没存电脑就死机了。
一晚上都在重新打，现在还没打完。
还能不能改题了啊！！！！！！！！！

2018-5-2

没考试，做提答题。
先来了一道UOJ83【UR #7】水题出题人
教你如何卡排序，不过竟然要让Bogo排序跑的比快速排序快，开什么玩笑，让最不靠谱的排序跑到比最靠谱的快。。。最后看了题解过去了。然后是一道【WC2014】非确定机给出输出让你猜输入。
还剩一个点，好像有点不好做，不知道能不能做出来。

2018-5-3

考了一场水水的考试
让后继续做提答【NOI2016】旷野大计算
很神的一道题，还有两个点没过。
有时间写一下题解

2018-5-4

考了一场不错的考试
$T1$ 会 $30$ 分， $T2$ 搞出了60 分， $T3$ 40 一共 130。
然后改题，先把$T2$改了。
然后是$T1$。 $T3$ 现在还没有改完。

2018-5-5

考了一下江苏省选题。
题目很神。
$T1$ 是一个叫做闵可夫斯基和的东西，这玩意基本没有中文资料，然后看的是英文维基
$T2$ 是一个会了之后很简单的DP，不会死也想不出来。
$T3$ 是一道水题，考场上直接A了。
发现5-3号提答的答案没存，花了不少时间重新跑出来。明天就出发了。
简单收拾一下东西。

「CodePlus 2018 3 月赛」白金元首与莫斯科

Fri, 13 Apr 2018 16:13:05 GMT

题目描述

莫斯科吹的寒风 / 仿佛昨日那场梦 / 啊你还会记得我吗

1941.12.

寒冷刺骨的天气、疲惫不堪的军队……包围首都的作战计划陷入了困境。空军或许是拯救战况的最后希望了，元首 Adolf 想道。

在一个 $n \times m$ 的网格区域中存在一个陆军单位需要补给，区域中的每个格子为空地或障碍物中的一种。航空舰队需要派遣若干运输机前往此区域，每一架运输机可以向两个相邻（有一条公共边）的空地投放物资。为防止不必要的损坏，一个标记为空地的格子至多只能得到一次投放。

由于天气原因，陆军单位所在的确切位置并不能确定。因此元首想知道，对于每个空地格子，当陆军单位在其中（视作障碍物）时，用若干（可以为 $0$）架运输机向其余空地投放任意数量的物资的不同方案数。两个投放方案不同，当且仅当存在一个格子在一个方案中被投放而另一方案中未被投放，或存在两个被投放的格子，在一个方案中被同一架运输机投放而在另一方案中非然。若仍有疑问，请参考「样例 1 解释」。

你需要编写程序帮助元首计算这些值对 $10^9+7$ 取模的结果。

输入格式

从标准输入读入数据。

第 $1$ 行：两个空格分隔的正整数 $n,m$ —— 网格区域的行数和列数。
接下来 $n$ 行：其中第 $i$ 行包含 $m$ 个空格分隔的整数 $A_{i1},A_{i2},\ldots,A_{im}$ —— 其中 $A_{ij} = 0$ 表示第 $i$ 行第 $j$ 列的格子为空地; $A_{ij} = 1$表示该格为障碍物。

输出格式

输出到标准输出。

对于每组数据输出 $n$ 行，第 $i$ 行包含 $m$ 个空格分隔的整数 $B_{i1}, B_{i2}, \ldots, B_{im}$ —— 若第 $i$ 行第 $j$ 列的格子为空地, $B_{ij}$ 为该格变为障碍物后投放的方案数；否则 $B_{ij} = 0$。

样例

样例 1 输入

2 4
0 0 0 0
0 0 0 1

样例 1 输出

14 13 10 22
15 11 17 0

样例 1 解释

以第 $2$ 行第 $1$ 列的空地格为例，其变为障碍物后的网格如下图，其中白色格子代表空地，黑色格子代表障碍物。
15 种方案如下图所示，不同颜色代表不同运输机的投放位置。

样例 2 输入

样例 2 输出

1882 827 1523 0 0
0 1189 791 1529 0
0 1106 979 823 1315
1810 899 1136 1075 1189

数据范围与提示

对于所有数据，有 $1 \leq n, m \leq 17$，$A_{ij} \in {0, 1}$。

子任务编号	分值	$n$	$m$
1	10	$\leq 2$	$\leq 17$
2	8	$\leq 5$	$\leq 5$
3	6	$\leq 9$	$\leq 9$
4	9	$\leq 12$	$\leq 12$
5	17	$\leq 15$	$\leq 15$
6	17	$\leq 16$	$\leq 16$
7	33	$\leq 17$	$\leq 17$

“Von allem Anfang an bin ich nur verraten und betrogen worden!”

题面与史实不尽相符。

来自 CodePlus 2018 3 月赛，清华大学计算机科学与技术系学生算法与竞赛协会荣誉出品。
Credit：idea/吕时清　命题/吕时清　验题/吕欣，王聿中
Git Repo：https://git.thusaac.org/publish/CodePlus3
感谢腾讯公司对此次比赛的支持。

题解

首先我们可以想到这道题一定是用插头$DP$

那么我们定义插头的状态 $1$ 为这个方向的格子与它为一架运输机投放
然后转移时注意一下合法性就可以了，很是简单的一道 $DP$
这样的话枚举每一个格子为障碍。
时间复杂度为 $O(n^2m^22^{m+1})$

但是这样并不能 $A$ 掉这道题，事实上，在 LibreOJ 它只能拿到 $33$ 分的好成绩。

33pts

正解
我们发现每次只有一个点不同
然后我们可以考虑合并。

我们正反分别进行一次插头$DP$ 将所有的状态储存下来
在考虑一个块的时候

将正反的 $DP$ 值乘起来就好了
需要判断一下合法性

时间复杂度$O(nm2^{m+1}+nm2^{m+1})$

没了

#include <cstdio>
#include <stdint.h>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 200000, BASE = 76543;
const int32_t MOD = 1e9 + 7;
int f[20][20][(1 << 18) + 1], g[20][20][(1 << 18) + 1];
int a[20][20], ans[20][20];
// int tmp[(1 << 18) + 1];
int DP1(int n, int m)
{
    // f[0].clear();
    int M = (1 << (m + 1)) - 1;
    f[1][0][0] = 1;
    // int now = 0;
    // int Ans = 0;
    register int32_t k = 0, i, j;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= m; j++)
        {
            // now ^= 1;
            // f[now].clear();
            for (k = 0; k <= M; k++)
            {
                int S = k;
                int Sum = f[i][j - 1][k];
                char L = (S >> (j - 1)) & 1, U = (S >> j) & 1;
                if (a[i][j])
                {
                    if (L == 0 && U == 0)
                        f[i][j][S] = (f[i][j][S] + Sum) % MOD;
                    continue;
                }
                else if (L == 1 && U != 1)
                {
                    int nxt = S ^ (1 << (j - 1));
                    f[i][j][nxt] = (f[i][j][nxt] + Sum) % MOD;
                }
                else if (L != 1 && U == 1)
                {
                    int nxt = S ^ (1 << j);
                    f[i][j][nxt] = (f[i][j][nxt] + Sum) % MOD;
                }
                else if (L != 1 && U != 1)
                {
                    int nxt = S ^ (1 << (j - 1));
                    if (i != n)
                        f[i][j][nxt] = (f[i][j][nxt] + Sum) % MOD;
                    nxt = S ^ (1 << j);
                    if (j != m) 
                        f[i][j][nxt] = (f[i][j][nxt] + Sum) % MOD;
                    f[i][j][S] = (f[i][j][S] + Sum) % MOD;
                }
                // if (S == 0)
                //     Ans += Sum;
            }
        }
        for (int k = 0; k <= M; k++)
            f[i + 1][0][k << 1] = f[i][m][k];
        // for (k = 0; k < f[now].p; k++)
        //     f[now].v[k].Id <<= 1;
    }
    return f[n][m][0];
}

// f->g
int DP2(int n, int m)
{
    // f[0].clear();
    int M = (1 << (m + 1)) - 1;
    g[n][m + 1][0] = 1;
    // int now = 0;
    // int Ans = 0;
    register int32_t k = 0, i, j;
    for (i = n; i >= 1; i--)
    {
        for (j = m; j >= 1; j--)
        {
            // now ^= 1;
            // f[now].clear();
            for (k = 0; k <= M; k++)
            {
                int S = k;
                int Sum = g[i][j + 1][k];
                char L = (S >> (j - 1)) & 1, U = (S >> j) & 1;
                if (a[i][j])
                {
                    if (L == 0 && U == 0)
                        g[i][j][S] = (g[i][j][S] + Sum) % MOD;
                    continue;
                }
                else if (L == 1 && U != 1)
                {
                    int nxt = S ^ (1 << (j - 1));
                    g[i][j][nxt] = (g[i][j][nxt] + Sum) % MOD;
                }
                else if (L != 1 && U == 1)
                {
                    int nxt = S ^ (1 << j);
                    g[i][j][nxt] = (g[i][j][nxt] + Sum) % MOD;
                }
                else if (L != 1 && U != 1)
                {
                    int nxt = S ^ (1 << (j - 1));
                    if (j != 1)
                        g[i][j][nxt] = (g[i][j][nxt] + Sum) % MOD;
                    nxt = S ^ (1 << j);
                    if (i != 1) 
                        g[i][j][nxt] = (g[i][j][nxt] + Sum) % MOD;
                    g[i][j][S] = (g[i][j][S] + Sum) % MOD;
                }
                // if (S == 0)
                //     Ans += Sum;
            }
        }
        for (int k = M; k >= 0; k--)
        // {
            g[i - 1][m + 1][k >> 1] = g[i][1][k];
            // printf ("%d %d %d %d\n", k >> 1, k, g[i - 1][m + 1][k >> 1], g[i][1][k]);
        // }
        // for (k = 0; k < f[now].p; k++)
        //     f[now].v[k].Id <<= 1;
    }
    return g[1][1][0];
}
int main()
{

    char n = read(), m = read();
    register int i, j, k;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= m; j++)
            a[i][j] = read();
    DP1(n, m), DP2(n, m);
    int M = (1 << (m + 1)) - 1;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= m; j++)
        {
            if (a[i][j]) continue;
            int Sum = 0;
            for (k = 0; k <= M; k++)
            {
                char L = (k >> (j - 1)) & 1, U = (k >> j) & 1;
                if (L == 0 && U == 0)
                    (Sum += 1ll * f[i][j - 1][k] * g[i][j + 1][k] % MOD) %= MOD;
            }
            ans[i][j] = Sum;
        }
    for (i = 1; i <= n; i++)
        for (j = 1; j <= m; j++)
            printf ("%d%c", ans[i][j], " \n"[j == m]);
    // while (1);
}

「Codeforces Round #418」白金夜话

Thu, 12 Apr 2018 14:08:21 GMT

题目描述

いつまでも止まらない　この胸のときめきで　一緒に踊ろう
随着永不停息的这心中的悸动，一起来跳舞吧！

给定坐标平面上 $n$ 个圆。任意两个圆的边界至多只有一个公共点 —— 即它们必定相离或相切。

对于一个圆的集合，定义其异或面积为平面上被该集合中奇数个圆覆盖的图形面积。

<img src="https://file.nekomio.com/picgo/1649775990635-145-1.webp" alt="Figure 1" style="display: block; margin: 0 auto;"> <div style="text-align:center; color:#999;">对于这个集合，浅蓝色部分图形的面积被计入异或面积内。</div>

现在需要将这 $n$ 个圆划分为两个集合，每个圆恰好在两个集合中的一个内。
<img src="https://file.nekomio.com/picgo/1649776008860-145-2.webp" alt="Figure 2" style="display: block; margin: 0 auto;"> <div style="text-align:center; color:#999;">对于这个集合，浅蓝色部分图形的面积被计入异或面积内。</div>

请求出合法的划分方案中，两个集合分别计算的异或面积之和的最大值。

输入格式

输入的第一行包含一个正整数 $n$ —— 圆的数目。

接下来 $n$ 行，每行包含三个整数 $x_i, y_i, r_i$ —— 描述一个圆心位于 ($x_i, y_i$)、半径为 $r_i$ 的圆。

输出格式

输出一个十进制实数 —— 合法的划分方案中，两个集合异或面积之和的最大值。

当选手答案与参考答案的相对误差或绝对误差不超过 $10^{-9}$ 时被视为正确。形式化地，若选手输出为 $a$，参考答案为 $b$，答案被视为正确当且仅当 $\frac{|a-b|}{\max(1,|b|)} \leq 10^{-9}$。

样例

样例输入 1

样例输出 1

138.23007676

样例解释 1

样例 1 的最优方案与「题目描述」一节中的图形对应。

样例输入 2

样例输出 2

289.02652413

数据范围与提示

$1 \leq n \leq 1000$
$-10^6 \leq x_i,y_i \leq 10^6, 1 \leq r_i \leq 10^6$

ささやかだけど　かけがえのない　歴史を重ねて
渺小平凡却无可替代的事物一点点重现着历史
偽りさえも　本当になる　君の隣りで
即使谎言在你身旁也会变得如此真实
　　　　　　　　　　　　　　　　　　——「白金ディスコ」

题解

其实不难吧, 但思路还是不错的。

首先在平面的几何关系不是很好搞，我们发现题目中保证必定相离或相切

那么圆就只有包含或者相离的关系

可以抽象成一颗树(森林)。
在图中包含他的圆为他的祖先
那么我们一个圆的贡献就与他在树上的深度有关

我们现在要把这个森林分成不相交的两部分

考虑 $DP$
定义 $F[i][j][k]$ 表示以 $i$ 为根的子树一个集合的深度的奇偶为 $j$ 另一个为集合的深度的奇偶为 $k$ 的最大面积和转移的时候先将子树合并
在枚举这个点放在哪个集合里

就完了。。。

好像还有一个贪心的做法。
但我不会啊。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 1005;
#define dis(_, __) (\
(((_).x - (__).x) * ((_).x - (__).x)) + \
(((_).y - (__).y) * ((_).y - (__).y))\
)
struct Circle
{
    double x, y, r;
    bool operator < (const Circle &b) const 
    {
        return r < b.r;
    }
}a[MAXN];
struct edge
{
    int END, next;
}v[MAXN << 1];
int first[MAXN], p;
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
bool vis[MAXN];
double f[MAXN][2][2], tmp[MAXN][2][2];
void DFS(int rt, int fa)
{
    // vis[rt] = 1;
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        DFS(v[i].END, rt);
        for (int j = 0; j <= 1; j++)
            for (int k = 0; k <= 1; k++)
                tmp[rt][j][k] += f[v[i].END][j][k];
    }
    for (int i = 0; i <= 1; i++)
        for (int j = 0; j <= 1; j++)
        {
            f[rt][i][j] = max(
                tmp[rt][i ^ 1][j] + a[rt].r * a[rt].r * (i == 0 ? 1 : -1),
                tmp[rt][i][j ^ 1] + a[rt].r * a[rt].r * (j == 0 ? 1 : -1)
            );
        }
}
int main()
{
    memset (first, -1, sizeof (first));
    int n = read();
    for (int i = 1; i <= n; i++)
        a[i].x = read(), a[i].y = read(), a[i].r = read();
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++)
            if (dis(a[i], a[j]) < a[j].r * a[j].r)
            {
                // printf ("%d %d\n", j, i);
                add(j, i);
                vis[i] = 1;
                break;
            }
    // while (1);
    double ans = 0;
    for (int i = 1; i <= n; i++)
        if (!vis[i])
        {
            DFS(i, 0);
            ans += f[i][0][0];
        }
    printf ("%.15f\n", ans * acos(-1.));
    // while (1);
}

「清华集训 2017」小 Y 和恐怖的奴隶主

Thu, 12 Apr 2018 10:25:17 GMT

题目描述

"A fight? Count me in!" 要打架了，算我一个。
"Everyone, get in here!" 所有人，都过来！

小Y是一个喜欢玩游戏的 OIer。一天，她正在玩一款游戏，要打一个 Boss。

虽然这个 Boss 有 $10^{100}$ 点生命值，但它只带了一个随从——一个只有 $m$ 点生命值的“恐怖的奴隶主”。

这个“恐怖的奴隶主”有一个特殊的技能：每当它被扣减生命值但没有死亡（死亡即生命值 $\leq 0$），且 Boss 的随从数量小于上限 $k$，便会召唤一个新的具有 $m$ 点生命值的“恐怖的奴隶主”。

现在小Y可以进行 $n$ 次攻击，每次攻击时，会从 Boss 以及 Boss 的所有随从中的等概率随机选择一个，并扣减 $1$ 点生命值，她想知道进行 $n$ 次攻击后扣减 Boss 的生命值点数的期望。为了避免精度误差，你的答案需要对 $998244353$ 取模。

输入格式

输入第一行包含三个正整数 $T,m,k$ 表示询问组数，$m,k$ 的含义见题目描述。

接下来 $T$ 行，每行包含一个正整数 $n$，表示询问进行 $n$ 次攻击后扣减 Boss 的生命值点数的期望。

输出格式

输出共 $T$ 行，对于每个询问输出一行一个非负整数，表示该询问的答案对 $998244353$ 取模的结果。

可以证明，所求期望一定是一个有理数，设其为$p/q (\mathrm{gcd}(p,q) = 1)$ 那么你输出的数 $x$ 要满足 $p \equiv qx \mod 998244353$。

样例

输入

输出

499122177
415935148
471393168

数据范围与提示

在所有测试点中, $1\leq T \leq 1000, 1 \leq n \leq 10^{18}, 1 \leq m \leq 3, 1 \leq k \leq 8$

各个测试点的分值和数据范围如下：

<table><thead><tr><th rowspan="1">测试点编号</th><th rowspan="1">分值</th><th rowspan="1">$T=$</th><th rowspan="1">$n \leq $</th><th rowspan="1">$m=$</th><th rowspan="1">$k=$</th></tr></thead><tbody><tr><td rowspan="1">1</td><td rowspan="1">3</td><td rowspan="4">10</td><td rowspan="2">10</td><td rowspan="1">1</td><td rowspan="1">1</td></tr><tr><td rowspan="1">2</td><td rowspan="1">8</td><td rowspan="3">2</td><td rowspan="1">8</td></tr><tr><td rowspan="1">3</td><td rowspan="1">7</td><td rowspan="8">$10^{18}$</td><td rowspan="1">3</td></tr><tr><td rowspan="1">4</td><td rowspan="1">12</td><td rowspan="1">7</td></tr><tr><td rowspan="1">5</td><td rowspan="1">30</td><td rowspan="1">20</td><td rowspan="6">3</td><td rowspan="1">5</td></tr><tr><td rowspan="1">6</td><td rowspan="1">10</td><td rowspan="1">500</td><td rowspan="1">6</td></tr><tr><td rowspan="1">7</td><td rowspan="1">10</td><td rowspan="1">200</td><td rowspan="2">7</td></tr><tr><td rowspan="1">8</td><td rowspan="1">5</td><td rowspan="1">1000</td></tr><tr><td rowspan="1">9</td><td rowspan="1">10</td><td rowspan="1">100</td><td rowspan="2">8</td></tr><tr><td rowspan="1">10</td><td rowspan="1">5</td><td rowspan="1">500</td></tr></tbody></table>

题解

20pts

可以直接$DP$
同[BZOJ 4832] [Lydsy2017年4月月赛]抵制克苏恩

100pts

发现每次转移都是一样的
然后就可以矩阵快速幂了。
然而并不能过 2333

时间复杂度为$O(Tcnt^3log(n))$, $cnt$不会超过200。
我们还需要优化

我们可以将转移矩阵的 $k$ 次方全部预处理出来，然后用一个 $1 \times cnt$ 的矩阵不断的去乘, 这样时间复杂度会被降到 $O(cnt^3log(n) + Tcnt^2log(n))$ 就可以过了。

好像是道水题

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline long long read()
{
    long long x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MOD = 998244353;
struct Matrix
{
    int a[200][200];
    int n, m;
    Matrix(int _n = 0, int _m = 0)
    {
        n = _n, m = _m;
        memset (a, 0, sizeof (a));
    }
    Matrix operator * (const Matrix &b) const 
    {
        Matrix ans(n, b.m);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                for (int k = 1; k <= b.m; k++)
                    ans.a[i][k] = (ans.a[i][k] + 1ll * a[i][j] * b.a[j][k]) % MOD;
        return ans;
    }
}A[64];
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int cnt[10][10][10], Index, IDans;
int main()
{
    int T = read(), m = read(), k = read();
    for (int i = 0; i <= k; i++)
        for (int j = 0; j <= (m == 1 ? 0 : k); j++)
            for (int l = 0; l <= ((m == 1 || m == 2) ? 0 : k); l++) if (i + j + l <= k)
                cnt[i][j][l] = ++Index;
    IDans = ++Index;
    if (m == 1)
    {
        for (int i = 0; i <= k; i++)
        {
            if (i > 0) (A[0].a[cnt[i][0][0]][cnt[i - 1][0][0]] += i * pow_mod(i + 1, MOD - 2) % MOD) %= MOD;
            (A[0].a[cnt[i][0][0]][cnt[i][0][0]] += pow_mod(i + 1, MOD - 2)) %= MOD;
            (A[0].a[cnt[i][0][0]][IDans] += pow_mod(i + 1, MOD - 2)) %= MOD;
        }
        A[0].a[IDans][IDans] = 1;
    }
    else if (m == 2)
    {
        for (int j = 0; j <= k; j++)
            for (int l = 0; l <= k; l++) if (l + j <= k)
            {
                if (l >= 1 && j + l + 1 <= k) 
                    (A[0].a[cnt[j][l][0]][cnt[j + 1][l][0]] += pow_mod(j + l + 1, MOD - 2) * l % MOD) %= MOD;
                if (l >= 1 && j + l + 1 > k)
                    (A[0].a[cnt[j][l][0]][cnt[j + 1][l - 1][0]] += pow_mod(j + l + 1, MOD - 2) * l % MOD) %= MOD;
                if (j >= 1)
                    (A[0].a[cnt[j][l][0]][cnt[j - 1][l][0]] += pow_mod(j + l + 1, MOD - 2) * j % MOD) %= MOD;
                (A[0].a[cnt[j][l][0]][cnt[j][l][0]] += pow_mod(j + l + 1, MOD - 2)) %= MOD;
                (A[0].a[cnt[j][l][0]][IDans] += pow_mod(j + l + 1, MOD - 2)) %= MOD;
            }
        A[0].a[IDans][IDans] = 1;
    }
    else
    {
        for (int i = 0; i <= k; i++)
            for (int j = 0; j <= k; j++)
                for (int l = 0; l <= k; l++) if (i + j + l <= k)
                {
                    if (i > 0)
                        (A[0].a[cnt[i][j][l]][cnt[i - 1][j][l]] += i * pow_mod(i + j + l + 1, MOD - 2) % MOD) %= MOD;
                    if (j > 0)
                    {
                        if (i + j + l + 1 <= k) 
                            (A[0].a[cnt[i][j][l]][cnt[i + 1][j - 1][l + 1]] += j * pow_mod(i + j + l + 1, MOD - 2) % MOD) %= MOD;
                        else 
                            (A[0].a[cnt[i][j][l]][cnt[i + 1][j - 1][l]] += j * pow_mod(i + j + l + 1, MOD - 2) % MOD) %= MOD;
                    }
                    if (l > 0)
                    {
                        if (i + j + l + 1 <= k) 
                            (A[0].a[cnt[i][j][l]][cnt[i][j + 1][l]] += l * pow_mod(i + j + l + 1, MOD - 2) % MOD) %= MOD;
                        else 
                            (A[0].a[cnt[i][j][l]][cnt[i][j + 1][l - 1]] += l * pow_mod(i + j + l + 1, MOD - 2) % MOD) %= MOD;
                    }
                    (A[0].a[cnt[i][j][l]][cnt[i][j][l]] += pow_mod(i + j + l + 1, MOD - 2)) %= MOD;
                    (A[0].a[cnt[i][j][l]][IDans] += pow_mod(i + j + l + 1, MOD - 2)) %= MOD;
                }
        A[0].a[IDans][IDans] = 1;
    }
    A[0].n = A[0].m = Index;
    for (int i = 1; i <= 63; i++)
        A[i] = A[i - 1] * A[i - 1];
    while (T--)
    {
        Matrix B(1, Index);
        B.a[1][cnt[m == 1][m == 2][m == 3]] = 1;
        long long n = read();
        for (int i = 0; i <= 63; i++)
            if (n & (1ll << i))
                B = B * A[i];
        printf ("%d\n", B.a[1][IDans]);
    }
}

「LibreOJ Round #8」MINIM

Wed, 11 Apr 2018 20:27:50 GMT

题目描述

取石子游戏的规则是这样的：有若干堆石子，两个玩家轮流操作，每个玩家每次要选一堆取走任意多个石子，但不能不取，无石子可取者输。

现在共有 $n$ 堆石子，其中第 $i$ 堆的数量为 $l_i$，现在 LCR 需要在每一堆中扔掉一部分（可以不扔也可以全扔），如果第 $i$ 堆的石子在 LCR 操作后还有剩余，LCR 就需要付出 $v_i$ 的代价。LCR 操作完成后神犇会搬来新的一堆个数在 $[0,m]$ 之间的石子，两人玩取石子游戏，LCR 先手。神犇搬运新的一堆石子时会保证自己（后手）必胜，如果他无法做到这一点，就会立即结束游戏。

现在 LCR 有 $q$ 次询问，每次给出一个 $c\in [0,m]$，请你回答如果要让神犇搬来的石子数为 $c$（不能让神犇结束游戏，即使这里要求 $c=0$），LCR 付出代价的总和至少是多少。如果 LCR 不可能通过调整石子使得神犇搬来的石子数为 $c$，输出 -1。

NIM is a game of strategy in which two players take turns removing stones from distinct piles. On each turn, a player must remove at least one stone, and may remove any number of stones provided they all come from the same pile. The player who has no stones to remove loses.

There are $n$ piles of stones, the $i$-th pile has $l_i$ stones. Alice needs to remove some of the stones from each pile (removing zero or all of the stones from a certain pile is allowed). If the $i$-th pile remains at least one stone after this operation, Alice has to pay a price of $v_i$. After Alice's operation, Bob will create a pile of stones whose number is in $[0,m]$ and add it to the game to make sure that Alice — the player who moves first in this NIM game will lose.If he can't ensure that Alice will lose,he will exit from the game immediately.

Now Alice has $q$ queries. Each query gives an integer $c$, and you need to calculate the minimal total price Alice needs to pay to ensure Bob’s new pile has exactly $c$ stones(making Bob exit from the game isn't allowed,even if $c=0$). If this is impossible, print -1 instead.

输入格式

第一行两个正整数 $n,m$。
接下来 $n$ 行每行两个正整数 $v_i,l_i$ 表示该堆石子的代价和数量。
接下来一行一个正整数 $q$。
接下来 $q$ 行每行一个正整数 $c$ 表示询问。

The first line contains two integers $n,m$.
Each of the following $n$ lines contains two integers $v_i,l_i$.
The next line contains an integer $q$. Each of the following $n$ lines contains an integers $c$.

输出格式

输出共 $q$ 行，依次表示每次询问的答案，无解输出 -1。

Output contains $q$ lines,containing the answer of each query in order.

样例

样例输入 Sample Input

样例输出 Sample Output

数据范围与提示

对于所有数据，$1 \leq n,q \leq 10^5, 1 \leq v_i \leq 10^9, 0 \leq l_i \leq m \leq 10^9, c \in [0, m]$。

详细的数据限制及约定如下（留空表示和上述所有数据的约定相同）

Subtask #	分值（百分比）	$n,q$	$l_i,m$	特殊性质
1	15	$\leq 10$	$\leq 10$	-
2	20	$\leq 100$	$\leq 100$	-
3	20	-	-	对于每个 $i$ 存在非负整数 $k$ 满足 $l_i=2^k-1$
4	20	$\leq 20000$	$\leq 20000$	$l_i,v_i$ 在范围内均匀随机（使用 `std::mt19937` 并对最大值取模）
5	25	-	-	$l_i,v_i$ 在范围内均匀随机（使用 `std::mt19937` 并对最大值取模）

题解

Subtask 1

直接爆搜

Subtask 2

考虑 $DP$
因为想要使得后手必胜，则初始状态的异或值为 $0$ , 那么就可以 $DP$ 了, 如果想要让神犇搬来的石子数为 $c$ 则前面的异或值需要为 $c$
然后定义 $f[i][j]$ 表示 $DP$ 到 $i$ 异或值为 $j$ 的最小花费，暴力转移即可
时间复杂度$O(nm^2)$
35pts

Subtask 3

这部分所有的 $i$ 存在非负整数 $k$ 满足 $l_i=2^k-1$
可以发现最优解一定是选一个
我们只要找大于等于 $c$ 的数中 $v_i$ 的最小值就可以了
55pts

Subtask 4 & 5

我们发现 Subtask 2 中的每一层 $f$ 数组是分段的
当数据随机时可以证明: 段数的期望是常数
CommonAnts的证明是这样的

考虑最小的一对满足 $m$ 以内二进制最高位均为 $1$ 的 $l_i,l_j$，那么这一对可以保证 $DP$ 数组的任意位置不超过 $v_i+v_j$。又根据算法四的分析，每一个权值和不超过 $v_i+v_j$ 的子集的贡献不超过一段。
由于随机，$v_i$ 的分布是均匀的，故枚举 $i,j$ 计算概率可得期望段数不超过 $\sum_{i \leq j}{2^{-j}\sum_{k=1}^{i+j}{S(i+j-\binom{k-1}{2}, k)}} = O(1)$ ($S$ 表示第二类斯特林数)
对于 $m$ 不是 $2$ 的幂的情况，可以分最高位和次高位分别分析，每一位产生的贡献都不超过上述的常数。

然后就可以记录段数转移了
时间复杂度 $O(n+q)$ (Subtask 4 & 5) 或 $O(nlog(n))$ (Subtask 3) 或 $O(nm)$ (Subtask 1 & 2)

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void gmin(int &a, int b) { if (a > b) a = b; }
const int MAXN = 100005;
int M;
struct data
{
    int v, l;
    data(int _v = 0, int _l = 0) : v(_v), l(_l) {}
    data operator + (const data &a) const 
    {
        data c(v + a.v, l | a.l);
        for (int i = M; i >= 0; i--)
            if (l & a.l & (1 << i))
            {
                c.l |= ((1 << (i + 1)) - 1);
                break;
            }
        return c;
    }
    bool operator < (const data &a) const 
    {
        return v < a.v;
    }
}a[MAXN], s[MAXN], t[MAXN], tmp[MAXN];
int cnt, len;
int Calc(int x)
{
    for (int i = 1; i <= cnt; i++)
        if (s[i].l >= x)
            return s[i].v;
    return -1;
}
int main()
{
    // freopen ("1.out", "w", stdout);
    int n = read(), m = read();
    for (int i = 1; i <= n; i++)
        a[i].v = read(), a[i].l = read();
    for (M = 31; M && (1 << (M - 1)) >= m; M--);
    s[++cnt] = data(0, 0);
    tmp[0] = data(0, -1);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= cnt; j++) 
            t[j] = s[j] + a[i];
        len = 0;
        int j = 0, k = 0, l;
        while (j < cnt || k < cnt)
        {
            data tp = j >= cnt ? t[++k] : (k >= cnt ? s[++j] : s[j + 1] < t[k + 1] ? s[++j] : t[++k]);
            for (l = 1; l <= len; l++)
                if (tmp[l].l >= tp.l)
                    break;
            if (l == len + 1)
                tmp[++len] = tp;
        }
        for (int j = 1; j <= len; j++)
            s[j] = tmp[j];
        cnt = len;
    }
    int q = read();
    while (q--)
    {
        printf ("%d\n", Calc(read()));
    }
}

「LibreOJ Round #6」花火

Wed, 11 Apr 2018 10:46:10 GMT

题目描述

「Hanabi, hanabi……」
一听说祭典上没有烟火，Karen 一脸沮丧。
「有的哦…… 虽然比不上大型烟花就是了。」
还好 Shinobu 早有准备，Alice、Ayaya、Karen、Shinobu、Yoko 五人又能继续愉快地玩耍啦！
「噢……！不是有放上天的烟花嘛！」Karen 兴奋地喊道。
「啊等等……」Yoko 惊呼。Karen 手持点燃引信的烟花，「嗯？？」
Yoko 最希望见到的是排列优美的烟火，当然不会放过这个机会…… 不过时间似乎已经不多了。

$n$ 个烟火排成一排，从左到右高度分别为 $h_1, h_2, \cdots, h_n$，这些高度两两不同。
每次 Yoko 可以选择两个相邻的烟火交换，这样的交换可以进行任意多次。
每次 Yoko 还可以选择两个不相邻的烟火交换，但这样的交换至多进行一次。
你的任务是帮助 Yoko 用最少次数的交换，使这些烟火从左到右的高度递增。

输入格式

第一行包含一个正整数 $n$。
第二行包含 $n$ 个正整数 $h_1, h_2, \cdots, h_n$，相邻整数之间用一个空格隔开。

输出格式

输出一个整数，表示最少的交换次数。

样例

样例输入

5
3 5 4 1 2

样例输出

样例解释

一开始，$5$ 个烟火的高度依次为 $3,5,4,1,2$。
第 $1$ 次，交换第 $4$ 根烟火和第 $5$ 根烟火，交换后烟火的高度依次为 $3,5,4,2,1$。
第 $2$ 次，交换第 $3$ 根烟火和第 $4$ 根烟火，交换后烟火的高度依次为 $3,5,2,4,1$。
第 $3$ 次，交换第 $1$ 根烟火和第 $2$ 根烟火，交换后烟火的高度依次为 $5,3,2,4,1$。
第 $4$ 次，交换第 $2$ 根烟火和第 $3$ 根烟火，交换后烟火的高度依次为 $5,2,3,4,1$。
第 $5$ 次，交换第 $1$ 根烟火和第 $5$ 根烟火，交换后烟火的高度依次为 $1,2,3,4,5$。
可以证明这是交换次数最少的方案。

数据范围与提示

对于所有数据，满足 $1 \leq n \leq 300,000, 1 \leq h_i \leq n, h_i$互不相同。

Subtask #	分值	$n$
1	$6$	$\leq 4$
2	$11$	$\leq 8$
3	$16$	$\leq 100$
4	$8$	$\leq 300$
5	$13$	$\leq 700$
6	$7$	$\leq 2,000$
7	$6$	$\leq 6,000$
8	$14$	$\leq 60,000$
9	$19$	$\leq 300,000$

题解

Subtask 1 & 2

直接去搜吧，记忆化一下
因为与$DP$没关系，就不写了

Subtask 3

需要一个多项式复杂度的做法
我们可以证明

总是可以假设交换不相邻元素在第一次进行。
证明: 假设交换的两个值为 $x$ 和 $y$ 那么，我们可以在第一次就交换他们然后可以构造出一个与原先交换次数相同的解
如果已经交换了不相邻元素，之后的最小交换次数等于此时排列的逆序对数。
证明: 设这一次交换的数为 $h[i]$ 与 $h[i + 1]$ 则这一次交换后他们与其他数$(j \neq i, j \neq i + 1)$的逆序对数是不变的。那么改变的只有他们之间的关系。又因为一个含有逆序对的数列中一定存在 $h[i] > h[i + 1]$ 所以只有不断的找到这样的数对交换即可，每次交换减少一个逆序对，交换次数为逆序对数。

可以 $n^2$ 枚举第一次交换的两个数，然后 $n^2$ 求逆序对
时间复杂度$O(n^4)$
33pts

Subtask 4

与上面的相同，只是用随便的一些方法将逆序对用 $n \log(n)$ 求
41pts

Subtask 5

这时我们需要一个 $O(n^3)$ 的做法
因为每次交换所改变的逆序对数很少，只要先求出来再 $O(n)$ 维护即可
54pts

Subtask 6 & 7

每次改变的逆序对并不用 $O(n)$ 求
将 $(x, h_x)$ 看做平面上的点
在第一次交换的时候，只有当 $h[i] > h[j]$ 时才有意义
然后我们发现这时减少的逆序对数就是以 $(i, h[i])$ 为左上角 $(j, h[j])$ 为右下角的矩形内部点数的二倍
然后用一个二维前缀和就可以了
67pts

Subtask 8 & 9

到这里其实就比较显然了
我们想要找的是一对点作为左上角与右下角使得其矩形内的点数最多。
这显然和我们做过的一道题一样，然后用线段树维护就好了
时间复杂度 $O(n\log(n))$
~~不知道为什么我的程序又长又慢 2333~~
知道了，我作死用的平衡树。。。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 300005;
#define size(_) ((_) ? (_)->s : 0)
#define _Max(_) ((_) ? (_)->Max : 0)
struct Node
{
    Node *ch[2];
    int s, v, key;
    int val, Max, lazy;
    Node(int x)
    {
        s = 0, v = x;
        key = rand();
        val = lazy = Max = 1;
        ch[0] = ch[1] = NULL;
    }
    void Pushup()
    {
        s = size(ch[0]) + size(ch[1]) + 1;
        Max = max(max(_Max(ch[0]), _Max(ch[1])), val);
    }
    void Pushlazy(int x)
    {
        val += x;
        lazy += x;
        Max += x;
    }
    void Pushdown()
    {
        if (lazy)
        {
            if (ch[0]) ch[0]->Pushlazy(lazy);
            if (ch[1]) ch[1]->Pushlazy(lazy);
            lazy = 0;
        }
    }
}*root;
Node *Merge(Node *A, Node *B)
{
    if (!A) return B;
    if (!B) return A;
    if (A->key < B->key)
    {
        A->Pushdown();
        A->ch[1] = Merge(A->ch[1], B);
        A->Pushup();
        return A;
    }
    else
    {
        B->Pushdown();
        B->ch[0] = Merge(A, B->ch[0]);
        B->Pushup();
        return B;
    }
}
typedef pair<Node*, Node*> DNode;
DNode Split(Node *rt, int k)
{
    if (!rt) return DNode(NULL, NULL);
    DNode o;
    rt->Pushdown();
    if (size(rt->ch[0]) >= k)
    {
        o = Split(rt->ch[0], k);
        rt->ch[0] = o.second;
        rt->Pushup();
        o.second = rt;
    }
    else
    {
        o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
        rt->ch[1] = o.first;
        rt->Pushup();
        o.first = rt;
    }
    return o;
}
int Rank(Node *rt, int x)
{
    if (!rt) return 0;
    return x <= rt->v ? Rank(rt->ch[0], x) : Rank(rt->ch[1], x) + size(rt->ch[0]) + 1;
}
void Insert(int x)
{
    int k = Rank(root, x);
    DNode y = Split(root, k);
    Node *n = new Node(x);
    root = Merge(y.first, Merge(n, y.second));
}
void Update(int x, int c)
{
    int k = Rank(root, x);
    DNode y = Split(root, k);
    if (y.second) y.second->Pushlazy(c);
    root = Merge(y.first, y.second);
}
void Update(int l, int r, int c)
{
    int k = Rank(root, l);
    DNode x = Split(root, k);
    int k2 = Rank(x.second, r + 1);
    DNode y = Split(x.second, k2);
    if (y.first) y.first->Pushlazy(c);
    root = Merge(x.first, Merge(y.first, y.second));
}
int Calc_Max(Node *rt)
{
    if (!rt->ch[1]) return rt->v;
    else return Calc_Max(rt->ch[1]);
}
int Query(int x)
{
    int k = Rank(root, x);
    DNode y = Split(root, k);
    int ans = _Max(y.second);
    root = Merge(y.first, y.second);
    return ans + 1;
}
set<int> t1, t2;
struct data
{
    int v, id, Mx;
    bool operator < (const data &a) const
    {
        return v < a.v;
    }
};
set<data> t3;
int n;
int a[MAXN], b[MAXN];
long long S[MAXN];
#define lowbit(_) ((_) & (-_))
void add(int x, int c)
{
    for (int i = x; i <= n; i += lowbit(i))
        S[i] += c;
}
long long Q(int x)
{
    long long ans = 0;
    for (int i = x; i >= 1; i -= lowbit(i))
        ans += S[i];
    return ans;
}
int st1[MAXN], st2[MAXN], top1, top2;
int main()
{
    // freopen ("columns3_2.in", "r", stdin);
    // freopen ("columns.out", "w", stdout);
    n = read();
    for (int i = 1; i <= n; i++)
        b[i] = a[i] = read();
    sort(b + 1, b + n + 1);
    for (int i = 1; i <= n; i++)
        a[i] = lower_bound(b + 1, b + n + 1, a[i]) - b;
    long long Sum = 0;
    for (int i = 1; i <= n; i++)
        Sum += Q(n) - Q(a[i]), add(a[i], 1);
    st1[++top1] = 1;
    t1.insert(1);
    for (int i = 2; i <= n; i++)
        if (a[i] > a[st1[top1]])
            st1[++top1] = i, t1.insert(i);
    st2[++top2] = n;
    t2.insert(n);
    for (int i = n - 1; i >= 1; i--)
        if (a[i] < a[st2[top2]])
            st2[++top2] = i, t2.insert(i);
    reverse(st2 + 1, st2 + top2 + 1);
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        if (!t1.count(i) && !t2.count(i))
        {
            Update(a[i], 1);
            t3.insert((data){a[i], i, Calc_Max(root)});
        }
        else
        {
            if (t1.count(i))
                Insert(a[i]);
            if (t2.count(i))
            {
                for (auto x : t3)
                    if (x.v > a[i]) break;
                    else
                        Update(x.v, x.Mx, -1);
                auto x2 = t3.begin();
                if (x2 != t3.end()) x2++;
                for (auto x = t3.begin(); x != t3.end(); )
                {
                    if (x->v > a[i]) break;
                    else
                        t3.erase(x);
                    x = x2;
                    if (x2 != t3.end())
                        x2++;
                }
                ans = max(ans, Query(a[i]));
            }
        }
    }
    printf ("%lld\n", min(Sum, Sum - (ans - 2) * 2));
}

BZOJ3884 上帝与集合的正确用法

Sat, 24 Mar 2018 20:33:58 GMT

Description

根据一些书上的记载，上帝的一次失败的创世经历是这样的：第一天，上帝创造了一个世界的基本元素，称做“元”。
第二天，上帝创造了一个新的元素，称作“$\alpha$”。“$\alpha$”被定义为“元”构成的集合。容易发现，一共有两种不同的“$\alpha$”。
第三天，上帝又创造了一个新的元素，称作“$\beta$”。“$\beta$”被定义为“$\alpha$”构成的集合。容易发现，一共有四种不同的“$\beta$”。
第四天，上帝创造了新的元素“$\gamma$”，“$\gamma$”被定义为“$\beta$”的集合。显然，一共会有$16$种不同的“$\gamma$”。
如果按照这样下去，上帝创造的第四种元素将会有$65536$种，第五种元素将会有$2^{65536}$种。这将会是一个天文数字。
然而，上帝并没有预料到元素种类数的增长是如此的迅速。他想要让世界的元素丰富起来，因此，日复一日，年复一年，他重复地创造着新的元素……
然而不久，当上帝创造出最后一种元素“$\theta$”时，他发现这世界的元素实在是太多了，以致于世界的容量不足，无法承受。因此在这一天，上帝毁灭了世界。
至今，上帝仍记得那次失败的创世经历，现在他想问问你，他最后一次创造的元素“$\theta$”一共有多少种？
上帝觉得这个数字可能过于巨大而无法表示出来，因此你只需要回答这个数对$p$取模后的值即可。你可以认为上帝从“$\alpha$”到“$\theta$”一共创造了$10^9$次元素，或$10^{18}$次，或者干脆$\infty$次。
一句话题意：求 $$2^{2^{2^{2^{\cdots}}}}$$
对$p$取模后的值

Input

接下来$T$行，每行一个正整数$p$，代表你需要取模的值

Output

$T$行，每行一个正整数，为答案对$p$取模后的值

Sample Input

Sample Output

0
1
4

HINT

对于$100%$的数据，$T<=1000$,$p<=10^7$

题解

根据扩展欧拉定理 $$x^b \equiv x^{b MOD \phi(p) + \phi(p)} (MOD P)$$ 对于所有的$P$都成立
然后我们就可以做了
已知任何数模$1$等于$0$
递归求解

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
long long pow_mod(long long a, int b, int MOD)
{
	long long ans = 1;
	while (b)
	{
		if (b & 1) ans = ans * a % MOD;
		b >>= 1;
		a = a * a % MOD;
	}
	return ans;
}
int phi(int x)
{
	int ans = x;
	for (int i = 2; i * i <= x; i++)
	{
		if (x % i == 0)
		{
			while (x % i == 0) x /= i;
			ans = ans - ans / i;
		}
	}
	if (x != 1) ans = ans - ans / x;
	return ans;
}
int Calc(int P)
{
	if (P == 1) return 0;
	int x = phi(P);
	return (int)pow_mod(2, Calc(x) + x, P);
}
int main()
{
	int T = read();
	while (T--)
	{
		int p = read();
		printf ("%d\n", Calc(p));
	}
}

BZOJ3640 JC的小苹果

Sat, 24 Mar 2018 20:05:41 GMT

Description

让我们继续JC和DZY的故事。
“你是我的小丫小苹果，怎么爱你都不嫌多！”
“点亮我生命的火，火火火火火！”
话说$JC$历经艰辛来到了城市$B$，但是由于他的疏忽$DZY$偷走了他的小苹果！没有小苹果怎么听歌！他发现邪恶的$DZY$把他的小苹果藏在了一个迷宫里。$JC$在经历了之前的战斗后他还剩下$hp$点血。开始$JC$在$1$号点，他的小苹果在$N$号点。$DZY$在一些点里放了怪兽。当$JC$每次遇到位置在$i$的怪兽时他会损失$A_i$点血。当$JC$的血小于等于$0$时他就会被自动弹出迷宫并且再也无法进入。
但是$JC$迷路了，他每次只能从当前所在点出发等概率的选择一条道路走。所有道路都是双向的，一共有$m$条，怪兽无法被杀死。现在$JC$想知道他找到他的小苹果的概率。
P.S.大家都知道这个系列是提高组模拟赛，所以这是一道送分题balabala

Input

第一行三个整数表示$n$，$m$，$hp$。接下来一行整数，第$i$个表示$JC$到第$i$个点要损失的血量。保证第$1$个和$n$个数为$0$。接下来$m$行每行两个整数$a$，$b$表示$ab$间有一条无向边。

Output

仅一行，表示JC找到他的小苹果的期望概率，保留八位小数。

Sample Input

Sample Output

0.87500000

HINT

对于$100%$的数据 $2 \leq n \leq 150$，$hp \leq 10000$，$m \leq 5000$，保证图联通。

题解

设$F[i][j]$ 表示剩余血量为$i$现在在点$j$的概率
首先相等的血量之间的转移有环，要用高斯消元
然而这样的复杂度为$hp*n^3$是不能过的
然后可以观察到，对于不同的$hp$方程组中只有常数项不同
那么我们可以先不考虑常数项, 求出每一个解是如何由常数项线性构造出来的
每次将常数项带入就好了

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 155;
struct edge
{
    int END, next;
}v[10005];
int first[MAXN], p;
int du[MAXN], t[MAXN];
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
double a[MAXN][MAXN], c[MAXN][MAXN];
double DP[10005][MAXN], tmp[MAXN];
void Gauss_Jordan(int n)
{
    for (int i = 1; i <= n; i++)
    {
        int k = i;
        for (int j = i + 1; j <= n; j++)
            if (fabs(a[j][i]) > fabs(a[k][i]))
                k = j;
        if (k != i)
        {
            for (int j = i; j <= n; j++)
                swap(a[i][j], a[k][j]);
            for (int j = 1; j <= n; j++)
                swap(c[i][j], c[k][j]);
        }
        for (int j = 1; j <= n; j++)
            if (j != i)
            {
                double t = a[j][i] / a[i][i];
                for (k = i; k <= n; k++)
                    a[j][k] -= a[i][k] * t;
                for (k = 1; k <= n; k++)
                    c[j][k] -= c[i][k] * t;
            }
    }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            c[i][j] /= a[i][i];
}

int main()
{
    int n = read(), m = read(), hp = read();
    memset (first, -1, sizeof (first));
    for (int i = 1; i <= n; i++) t[i] = read();
    for (int i = 1; i <= m; i++)
    {
        int b = read(), d = read();
        add(b, d), du[b]++;
        if (b != d) add(d, b), du[d]++;
    }
    for (int i = 1; i <= n; i++)
    {
        a[i][i] = 1, c[i][i] = 1;
        if (t[i] == 0)
        {
            for (int j = first[i]; j != -1; j = v[j].next)
                if (v[j].END != n)
                    a[i][v[j].END] -= 1.0 / du[v[j].END];
        }
    }
    Gauss_Jordan(n);
    double ans = 0;
    for (int i = hp; i >= 1; i--)
    {
        memset (tmp, 0, sizeof (tmp));
        if (i == hp)
            tmp[1] = 1;
        for (int j = 1; j <= n; j++)
            if (t[j] && i + t[j] <= hp)
                for (int k = first[j]; k != -1; k = v[k].next)
                    if (v[k].END != n)
                        tmp[j] += DP[i + t[j]][v[k].END] / du[v[k].END];
        for (int j = 1; j <= n; j++)
            for (int k = 1; k <= n; k++)
                DP[i][j] += tmp[k] * c[j][k];
        ans += DP[i][n];
    }
    printf ("%.8f\n", ans);
    // while (1);
}

BZOJ1129 [POI2008]Per

Sat, 24 Mar 2018 19:46:46 GMT

Description

给你一个序列s，你把这个序列的所有不同排列按字典序排列后，求s的排名mod m

Input

序列的长度$n < 300000,m$
$n$个数，代表序列s

Output

排名mod m

Sample Input

4 1000
2 1 10 2

Sample Output

HINT

All the permutations smaller (with respect to lexicographic order) than the one given are: (1,2,2,10), (1,2,10,2), (1,10,2,2) and (2,1,2,10). $2 \leq m \leq 10^9$, $1 \leq S_i \leq 300000$

题解

逐位考虑
考虑前$i-1$位与这个数列相等，第$i$位比他小的数量
设有$g[i]$个数比他这一位小，那么答案为$g[i]*\frac{F[n - 1]}{\prod_{j = 1}^{n}{F[w[i]]}}$
其中$F[i]$位$i$的阶乘,$W[i]$为排除了前面已经确定的数后$i$的数量

这样就可以算出答案了
然而我们发现模数可能不是质数，那怎么办呢?
我们可以把他质因数分解，将模数拆成$p^k$相乘的形式
对于每一个$p^k$求模他的结果然后使用$CRT$合并
可是阶乘如果是$p^k$的倍数就会得$0$, 我们可以将阶乘拆成$a*p^b$的形式
可以实现乘法与除法。
然后解决了。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 300005;
long long a[MAXN], b[MAXN], c[MAXN], g[MAXN];
int Sum[MAXN], n, m;
long long B, P, PhiP, K;
long long pow_mod(long long a, int b, long long MP)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MP;
        b >>= 1;
        a = a * a % MP;
    }
    return ans;
}
long long Inv(long long x)
{
    return pow_mod(x, PhiP - 1, P);
}
struct Num
{
    long long a, b;
    Num(){a = 0, b = 0; }
    Num(int _a)
    {
        a = _a;
        while (a % B == 0)
            a /= B, b++;
    }
    Num(long long _a, long long _b): a(_a), b(_b) {}
    Num operator * (const Num &c) { return Num(a * c.a % P, b + c.b); }
    Num operator / (const Num &c) { return Num(a * Inv(c.a) % P, b - c.b); }
    long long val()
    {
        if (!a || b >= K) return 0;
        long long x = a, k = b, c = B;
        while (k)
        {
            if (k & 1) x = x * c % P;
            k >>= 1;
            c = c * c % P;
        }
        return x;
    }
    void Set(int x)
    {
        a = x, b = 0;
        while (a % B == 0)
            a /= B, b++;
    }
}F[MAXN];
#define lowbit(_) ((_) & (-_))
void A(int x, int c)
{
    for (int i = x; i <= n; i += lowbit(i))
        Sum[i] += c;
}
int Q(int x)
{
    int ans = 0;
    for (int i = x; i >= 1; i -= lowbit(i))
        ans += Sum[i];
    return ans;
}
int cnt;
long long ans[5000], Mp[5000], Phi[5000];
void Solve()
{
    cnt++;
    Mp[cnt] = P, Phi[cnt] = PhiP;
    F[0].Set(1);
    for (int i = 1; i <= n; i++) F[i].Set(i);
    for (int i = 1; i <= n; i++) F[i] = F[i] * F[i - 1];
    for (int i = 1; i <= n; i++) c[i] = 0;
    for (int i = 1; i <= n; i++) c[a[i]]++;
    Num t(1, 0), tmp;
    for (int i = 1; i <= n; i++) t = t * F[c[i]];
    for (int i = 1; i <= n; i++)
    {
        if (g[i]) tmp.Set(g[i]), ans[cnt] = (ans[cnt] + (tmp * F[n - i] / t).val()) % P;
        t = t / F[c[a[i]]] * F[c[a[i]] - 1];
        c[a[i]]--;
    }
}
void Divide(int x)
{
    for (int i = 2; i * i <= x; i++)
        if (x % i == 0)
        {
            B = i, P = 1, PhiP = 1, K = 0;
            while (x % i == 0)
                P *= i, PhiP *= i, K++, x /= i;
            PhiP /= i, PhiP *= i - 1;
            Solve();
        }
    if (x != 1)
    {
        B = x, P = x, PhiP = x - 1, K = 1;
        Solve();
    }
}
long long CRT(long long *a, long long *b, int n)
{
    long long N = 1, Ni, now, ans = 0;
    for (int i = 1; i <= n; i++) N *= a[i];
    for (int i = 1; i <= n; i++)
    {
        Ni = N / a[i];
        now = pow_mod(Ni, Phi[i] - 1, a[i]);
        ans = (ans + (b[i] * now % N) * Ni % N) % N;    
    }
    return ans;
}
int main()
{
    n = read(), m = read();
    for (int i = 1; i <= n; i++)
        b[i] = a[i] = read();
    sort(b + 1, b + n + 1);
    int cnt = unique(b + 1, b + n + 1) - b - 1;
    for (int i = 1; i <= n; i++)
        a[i] = lower_bound(b + 1, b + cnt + 1, a[i]) - b;
    for (int i = 1; i <= n; i++)
        c[a[i]]++;
    for (int i = 1; i <= n; i++) A(i, c[i]);
    for (int i = 1; i <= n; i++)
        g[i] = Q(a[i] - 1), A(a[i], -1);
    Divide(m);
    printf ("%lld\n", (CRT(Mp, ans, ::cnt) + 1) % m);
}

省选集训日记

Mon, 19 Mar 2018 21:37:47 GMT

2018-3-19 多云

第一天写日记昨天打了一场UR今天把题改了一下。又做了一下放假前的那场考试题，还没有做完，还要找时间补。今天一天下来打的题都不简单，刚放假回来状态也不是很好，主要是比较困。中午起来想了很多，想到去年的我这时在干什么，不知不觉都过去一年了。好怀念那时轻松的日子。但现在还是要面对啊，先过了省选再说，无论结果如何，也都会确定了。

2018-3-20 ~ 21

生活就是改题吧。。
一连考了两天, 题还都没有改完都是神题。
D1T1贪心, D1T2 是一道2-SAT + Trie, D1T3 是一个DP
D2T1计算几何的DP, D2T2 是一个平横树维护的模拟, D2T3是一个多项式算法。
博客还是要尽力更新的吧。

2018-3-22

终于把题给改完了
D2T3，D1T3真是不好改。
晚上打了一道题，还没打完，一道CRT合并的组合数的题目
组合数模非质数: 将模数分解质因子,对于每一个$P ^ k$都算出$%$他意义下的答案，然后用CRT合并，对阶乘搞一下拆成$a*p^b$ 以为$a$与$p^k$互质所以可以求逆元了。
然后听ryf分享一道题UOJ76懒癌，看到题面感觉很熟悉啊。解法也是非常的强大，将搜索转化为图论。

2018-3-23

又是考试的一天
第三题有点熟悉，这道题的处理方法和昨天那道题好像一样啊。
然后就打了，结果还是没A, 有一个地方没开long long在计算过程中炸掉了。
前两题都是神题，第二题是一道看不出来是杜教筛的杜教筛，用的容斥系数$\mu$ 然后推一下式子。
第一题又是一道记忆化搜索DP

2018-3-24

今天没考试，那就去刷题吧。
简单的做了一下数学专题
学了一下高斯约当消元法。又打了一道$LCT$的题目
补了一点博客。
计划再看看概率期望相关的题目

2018-3-25

考试考试考试
第一道题是一道比较简单的网络流, 可以先二分然后跑类似于文理分科的最小割
第二题是一道三维的几何题, 考试的时候没敢写，主要是没想到用单位向量的倍数来列方程，然后就用一些高考数学的知识就能解决了
第三题是一道$DP$对小质数状压，大质数枚举，可以跑过纯状压跑不过的测试点
然后就没了

2018-3-26

考试考试考试
第一题看起来是一道莫比乌斯反演? 推了推没推出式子,先打个部分分再说吧。
然后看第二题，暴搜有分? 等等, 我好想会$n^3$的做法, 码码码, 打完调过样例, 好让我打个对拍, $n = 3$一拍就出错，额，调调调，调过了我的小数据，再一测样例，(⊙o⊙)… 又不对了，啊啊啊。我这个好像不对??? 不要啊，然后还是弃疗了2333
弃疗后看第三题，好像不难啊，等等，这不是半平面交裸题么，十几分钟就打完了，结果死活不出样例，什么鬼啊? 我半平面交没错啊。考试结束也没改出来，最后发现代码里这样一句const int eps = 1e-8成功把我炸死。改了就过了。
第一题的正解是一个优化了的暴力, 根据调和级数得复杂度为$n^2log(n)$还卡常。
第二题是一个看起来很简单的$DP$，不知道是因为想的太难还是真的很难没做出来。
明天还考试。。

2018-3-27

一天两试真爽啊
上午考了一场，第一题先把暴力打了，然后看第二题，咦，这不是原题么? 好像连样例都一样的啊。码码码，打完之后简单拍了一下感觉没问题了去做第三题，第一眼二分图，感觉不对，在一眼好想可以用网络流，先建了个最大费用最大流，发现不对，然后想是不是可以最小割啊。画了画图，然后发现这图好想有点熟悉啊，等等，我是不是做过一道和这个一样的题啊，然后就开打了，没对拍，眼动查了几发错，好想没什么问题。
最后得分和我的估分一致，没有什么问题。
考完之后，于老师说，下午再考一场，我心里一惊，我的天还考啊。啊啊啊。
下午起来之后有点困，一点四十七到了机房，坐着犯困，本来说好的两点考试，然后老师看我们没什么事干，就直接开考了
上来先浏览一下题面，发现暴力分给很多，这种类型题做起来也挺舒服。看完题面，周围一片键盘声，心里有点慌，他们不会都要$A$题了吧
不，我要冷静一下，我想的和他们应该也差不多，那，先让我上个厕所冷静一下。
回来之后发现，三道题好想都可以拿到不少的分数啊，然后剩下的时间就用在码题上了。
第一题是一道分类讨论，看起来不是很好搞。
第二题前$30$分可以直接枚举，还有二十分可以$DP$出来。
第三题我好想会一个$nlog^2(n)$的做法啊，考完试后才发现是$nlog^3(n)$的。然而拿到了不少分啊
第二题的正解是将我的那个$DP$扩展到树上，打出来后发现其实非常简单，我觉得在$NOIP$前都有可能会做，我是被省选模拟赛吓到了吗？怎么不敢打正解了啊？
第三题可以在我的程序上稍加修改去掉一个比较大的$log$就可以轻松过掉了，其实我的程序开了O2也是可以过的啊，说好的开O2呢。
明天还考试，题还没改完呢啊。。

2018-3-28

早上起来好困，到机房后继续看昨天的题的题解。
到了考试的时间就考吧。
上来一看，这好想和昨天的是一套题，可是画风好想不大一样啊
看了看第一题，发现和昨天下午T2的一个部分分有点相似，可是数据范围大了不少，然后就开始推DP方程$O(n^3)$不用过脑子， $O(n^2log(n))$是NOIP水平的DP，这样是$60$分，然后想$100$分的做法，想了一会发现好想没什么思路，然后看了一下第二题，发现没什么思路，暴力也不是很好打，然后看第三题，看起来好想很好拿分? 开始先把暴力打上，然后发现，好想可以用动态点分治，是不是可以满分?(死+1)，然后开始打，打着打着发现好像不能处理修改操作? 没事，没有修改也有$50$分(死+2)，比暴力多了不少，继续打，调调调，最后还是没调出来，再给我$10$分钟就行啊，说好的四个半小时呢?为啥又是四个小时。 $T2$最后还是没打上。
最后$T2$好像是这三道题中最好做的?应该多给点时间给$T2$的。
这次考试最大是失误是错误的估计了我$T3$打法的难度，没有正确的处理好每道题的时间分配，否则第二题还是能拿不少分呢。
下次一定注意。

2018-3-29

又是考试的一天
开始考试后看第一题，想出了$70$分的$DP$然后想了想，也没想出怎么优化。
看第二题，只会暴力，第三题只会暴力。然后就完了。
其实第一题的正解很简单，但是我没有想出来，主要的一个原因是$DP$数组转移的方式问题，以我的转移方式只能看出他是一个区间加，但如果换一个方向，就能看出前缀和了，然后就是正解了。
第二题是一个很简单的线段树，但是我没想出来，主要是因为没有深入的挖掘$n \leq 100$这个条件。
第三题是真的很好，先将二维转化为一维，然后可以字符串匹配，$FFT$优化搞掉这道题，这个真的是不容易想出来。

2018-3-30

没改完题。。。
T1上来一看是道水题，结果老师说题面是错的，然后就不会了，其实正解也就是一个简单的$Hash$
T2没有什么思路，就打了一点骗分，其实可以用模拟退火水过去，正解是拉格朗日乘数法。
T3题面中给出了精度问题，然后就想到了取$log10$这个操作，之后需要用线段树维护排序和区间和。

2018-3-31 ~ 4-1

3-31号上午考了一场试上来先看$T1$发现一眼看出了非常水的$50$分，然后发现不会了，尝试去想$100$分发现复杂度一直不对，后来加了一个单调偏分，又多拿了$10$分。
然后看$T2$发现暴力不是很好打，想了想，发现他的状态的检验非常快，然后想到了昨天学习的模拟退火，然后一发退火上去，过了样例，然后造极限数据，发现跑一次一个数，每次都不是最优，想了想算了，应该能拿到点分，但应该不多，然后发现有$50$分，很开心，真·信仰退火， $T3$真的是一点都不会。。。
其实$T1$可以通过两个单调用线段树维护， $T2$是网络流，$T3$是一道$Hash$+$BurnSide$的题。
4-1做题，先把前天的$T3$改掉，用了快一个上午，真是打不动数据结构了啊。
然后做了做NOI泳池因为不会特征多项式，用快速幂跑了$90$分就这样了。然后做【UER #4】量子态的棋盘一道不是很显然的轮廓线$DP$，但打起来不是很难。
还要把Normal打完啊

2018-4-2

考了两场，两场的$T2$和$T3$都不难，但是$T1$都不是很简单。
$T1$ 全场最佳。
题还没有改完。

2018-4-3

上午考了一场试，算下来还有一两天就省选了啊。
一看$T1$看起来部分分很好拿，事实也确实如此，先打$60$分的部分分，然后想先看看其他题，然后留一点时间给第一题。
然后看$T2$发现不是很会做，先打了$20$分的暴力，感觉还有$10$分好像可以拿，然后我先看第三题去了。
$T3$不是很会打暴力，打了一个多小时的暴力，最后因为重边，出了问题。
因为$T3$费了太多时间， $T2$和$T1$也没有再去打，本来以为还有一个半小时的，其实只要半个小时了。
然后就没打我本来应该得到的那部分分。

ENDL

UR17 题解

Mon, 19 Mar 2018 20:42:51 GMT

A. 【UR #17】滑稽树上滑稽果

“滑稽树上滑稽果，滑稽树下你和我” 听到这熟悉的句子，他猛然忆起年少时最喜欢的节目，彼时单纯而简单的生活，以及那幼稚而天真的苦恼。幼年的他常常苦恼这么一个问题：他有 $n$ 个滑稽果，第 $i$ 个滑稽果的大小为 $a_i$。他现在想把它们构成一棵任意形态的有根树，每个点的滑稽度为它的大小和它父亲的滑稽度的 $and$，其中 $and$ 表示按位与运算，例如 $2\ and\ 3=2,1\ and\ 0=0,\ 1\ and\ 1=1$。特别地，根的滑稽度等于他的大小。为了世界的和平，他希望能最小化这棵树上所有滑稽果的滑稽度之和。请问你能帮他解决这个问题吗？

输入格式

第一行一个正整数 $n$。接下来一行有 $n$ 个正整数 $a_i$, 表示 $i$ 个滑稽果的大小。

输出格式

一行一个整数，表示最小的滑稽度之和。

样例一

input

5
12 9 14 17 15

output

样例二

input

10
42256 116359 103553 58560 49680 99204 37408 57353 110732 33797

output

<table><thead><tr><th width="10%">子任务</th> <th width="10%">分值</th> <th width="13%">$n$的规模</th> <th width="13%">$a_i$的规模</th> <th>特殊性质</th> </tr></thead><tbody><tr><td>1</td><td>5</td><td>$n \leq 9$</td><td rowspan="6">$1 \leq a_i \leq 2 \times 10^5$</td><td>无</td></tr><tr><td>2</td><td>10</td><td>$n \leq 12$</td><td>保证存在合法的最优解是一条链</td></tr><tr><td>3</td><td>10</td><td>$n \leq 100$</td><td rowspan="2">保证存在合法的最优解是一条链。并且从根开始的每个滑稽值构成了一个序列，保证解的这个序列的字典序，在所有链对应的序列中最小</td></tr><tr><td>4</td><td>15</td><td>$n \leq 10^5$</td></tr><tr><td>5</td><td>30</td><td>$n \leq 100$</td><td rowspan="2">无</td></tr><tr><td>6</td><td>30</td><td>$n \leq 10^5$</td></tr></tbody></table>

A. 题解

这题面有毒吧。。。

对于第一个Subtask可以直接枚举父节点时间复杂度$O(n^n)$
然后是第二个Subtask据说可以用$n!$的时间复杂度枚举，但不知道为什么过不去。。。
第三四的Subtask保证了字典序最小，我们可以暴力跑一下$O(n^2)$过掉$n<=100$的数据，而对于$n<=10^5$的数据我们可以Sort一下$O(nlog^2(n))$跑过去核心代码在下面

for (int i = 1; i <= n; i++) a[i] = read();
Now = 0x7fffffffffffffffll;
long long ans = 0;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++)
{
    ans += (Now & a[i]);
    if ((Now & a[i]) != Now)
    {
        Now = (Now & a[i]);
        sort(a + i + 1, a + n + 1, cmp);
    }
}
printf ("%lld\n", ans);

bool cmp(long long c, long long d)
{
    if ((Now & c) == (Now & d)) return c > d;
    return (Now & c) < (Now & d);
}

剩下的就是正解了
把相同的位拿出来，这些位要么一定是每次没贡献，要么一定是每次有贡献。
所以我们一样先把每个数都一样的那些位拿出来，剩下的位我们等于是希望尽快把他们变成0。
用一个DP
$f[S]$表示当$S$集合的值为$1$时将他消为$0$的最小代价
转移的时候枚举$a[i]$，令$F[S] = F[S \& a[i]] + (S \& a[i])$
这样是$O(na)$的配合上前面的部分分，可以有70分了。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 1e5 + 5;
long long a[MAXN], C[MAXN];
int n;
bool rm[10];
int Count[10];
inline void Trans(int x, long long *c)
{
    int cnt = 0;
    for (int i = 1; i <= n - 2; i++) c[i] = 0;
    while (x) c[++cnt] = x % n, x = x / n;
    for (int i = 1; i <= n - 2; i++) c[i]++;
}
struct edge
{
    int END, next;
}v[20];
int first[10], p;
bool flag[100005];
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int Sum;
void DFS(int rt, int fa)
{
    if (fa != 0) C[rt] = (C[fa] & a[rt]);
    Sum += C[rt];
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (v[i].END == fa) continue;
        DFS(v[i].END, rt);
    }
}
long long Now;
bool cmp(long long c, long long d)
{
    if ((Now & c) == (Now & d)) return c > d;
    return (Now & c) < (Now & d);
}
long long f[(1 << 18) + 1], S[(1 << 18) + 1];
int main()
{
    n = read();
    if (n <= 100)
    {
        long long SAME = 0x7fffffffffffffffll;
        for (int i = 1; i <= n; i++) a[i] = read(), SAME = (SAME & a[i]);
        int N = (1 << 18) - 1;
        int cnt = 0;
        for (int i = 1; i <= N; i++)
            S[++cnt] = (i | SAME) ^ SAME;
        memset (f, 0x3f, sizeof (f));
        f[0] = 0;
        sort(S + 1, S + cnt + 1);
        for (int i = 1; i <= cnt; i++)
            for (int j = 1; j <= n; j++)
                f[S[i]] = min(f[S[i]], f[S[i] & a[j]] + (S[i] & a[j]));
        printf ("%lld\n", 1ll * SAME * n + f[S[cnt]]);
    }
    else
    {
        for (int i = 1; i <= n; i++) a[i] = read();
        Now = 0x7fffffffffffffffll;
        long long ans = 0;
        sort(a + 1, a + n + 1, cmp);
        for (int i = 1; i <= n; i++)
        {
            ans += (Now & a[i]);
            if ((Now & a[i]) != Now)
            {
                Now = (Now & a[i]);
                sort(a + i + 1, a + n + 1, cmp);
            }
        }
        printf ("%lld\n", ans);
    }
    // while (1);
}

对于满分做法我们可以每次不枚举一个$a[i]$，而是枚举一个子集$T$，强制把这个子集$T$变成$0$。
我们需要知道哪些$T$可以变为$0$
可以用枚举子集的方法，(但是因为太暴力被Hack了 2333) 转移是相似的。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 1e5 + 5;
long long a[MAXN], C[MAXN];
int n;
long long Now;
bool cmp(long long c, long long d)
{
    if ((Now & c) == (Now & d)) return c > d;
    return (Now & c) < (Now & d);
}
long long f[(1 << 18) + 1], S[(1 << 18) + 1];
int cnt[(1 << 18) + 1];
int main()
{
    n = read();
    if (n <= 100000)
    {
        long long SAME = (1 << 18) - 1;
        for (int i = 1; i <= n; i++) a[i] = read(), SAME = (SAME & a[i]);
        int N = (1 << 18) - 1;
        for (int i = 1; i <= n; i++) a[i] ^= SAME;
        for (int i = 1; i <= n; i++)
        {
            long long t = N ^ a[i];
            for (int j = t; j; j = (j - 1) & t)
                cnt[j] = 1;
        }
        memset (f, 0x3f, sizeof (f));
        for (int i = 1; i <= n; i++) f[a[i]] = a[i];
        for (int i = N; i >= 1; i--) 
            if (f[i] < 0x3f3f3f3f3f3f3f3f)
                for (int j = i; j > 0; j = (j - 1) & i)
                    if (cnt[j])
                        f[i ^ j] = min(f[i ^ j], f[i] + (i ^ j));
        printf ("%lld\n", 1ll * SAME * n + f[0]);
    }
    else
    {
        for (int i = 1; i <= n; i++) a[i] = read();
        Now = 0x7fffffffffffffffll;
        long long ans = 0;
        sort(a + 1, a + n + 1, cmp);
        for (int i = 1; i <= n; i++)
        {
            ans += (Now & a[i]);
            if ((Now & a[i]) != Now)
            {
                Now = (Now & a[i]);
                sort(a + i + 1, a + n + 1, cmp);
            }
        }
        printf ("%lld\n", ans);
    }
    // while (1);
}

B. 【UR #17】滑稽树下你和我

我，年幼的人赢，总是和我的同桌一起在滑稽树下讨论问题。
我的滑稽树是一棵长在平面上的，有 $n$ 个点的树。点从 $1$ 到 $n$ 标号。这 $n$ 个点满足任意三点互不共线，并且树的边不相交。
现在我都和我的同桌一起在滑稽树上每人各控制一个点。我的点最开始在 $\mathrm{stx}$，我的同桌的点最开始在 $\mathrm{sty}$。我们可以任意沿着树的边移动各自的点。当两个点都在树上的某个叶子的时候游戏就结束了。
现在，我想要最小化任意时刻我们两个所控制的点之间距离的最大值。请问你能帮我解决这个问题吗？注意某个时刻两个点可能都在某一条边上，这时候的距离也要统计入答案。
一句话题意：给定一棵平面上的树，两个点在树上任意移动，最小化从开始到两个点都到达叶子的任意时刻两个点直线距离的最大值。
<h3>输入格式</h3> 第一行三个正整数 $n,\mathrm{stx},\mathrm{sty}$。
接下来 $n$ 行有 $2$ 个整数 $x_i,y_i$，表示第 $i$ 号节点的坐标。
接下来 $n-1$ 行有 $2$ 个整数 $a_i,b_i$，表示树上的一条边。
<h3>输出格式</h3> 输出一行，包含一个实数，表示最小的任意时刻我们两个所控制的点之间距离的最大值。
你的答案与参考答案的绝对误差或相对误差不超过 $10^{−6}$ 时被认为是正确的。
<h3>样例一</h3> <h4>input</h4>

<h4>output</h4>

1.0000000000

</pre>

<h3>样例二</h3> <h4>input</h4>

<h4>output</h4>

69.2964645563

<h3>限制与约定</h3> 对于全部数据，$3\le n\le 1000$，$0\le x_i,y_i \le 10^6$。 <table><thead><tr><th>子任务</th> <th>分值</th> <th>$n$</th> <th>特殊性质</th> </tr></thead><tbody><tr><td>1</td> <td>5</td> <td rowspan="2">$\le 10$</td> <td>$\mathrm{stx}$ 和 $\mathrm{sty}$ 均为叶子</td> </tr><tr><td>2</td> <td>25</td> <td>无</td> </tr><tr><td>3</td> <td>25</td> <td>$\le 200$</td> <td>无</td> </tr><tr><td>4</td> <td>15</td> <td rowspan="2">$\le 1000$</td> <td>保证存在最优方案，在任意时刻至少有一端点位于树的某结点上</td> </tr><tr><td>5</td> <td>30</td> <td>无</td> </tr></tbody></table>

B. 题解

第一个Subtask可以直接输出两点距离
对于保证存在最优方案，在任意时刻至少有一端点位于树的某结点上的部分
先二分答案
定义$f[i][j]$表示两个点为$i, j$是否可行, 按照定义枚举转移


bool Judge(double mid)
{
    memset (f, 0, sizeof (f));
    f[stx][sty] = f[sty][stx] = 1;
    queue<pair<int, int> > Q;
    Q.push(pair<int, int>(stx, sty));
    while (!Q.empty())
    {
        pair<int, int> k = Q.front(); Q.pop();
        int x = k.first, y = k.second;
        if (x == y || (du[x] == 1 && du[y] == 1)) return 1;
        for (int i = first[x]; i != -1; i = v[i].next)
        {
            if (!f[v[i].END][y] && dis(a[v[i].END], a[y]) <= mid)
            {
                f[v[i].END][y] = f[y][v[i].END] = 1;
                Q.push(pair<int, int>(v[i].END, y));
            }
        }
        for (int i = first[y]; i != -1; i = v[i].next)
        {
            if (!f[x][v[i].END] && dis(a[v[i].END], a[x]) <= mid)
            {
                f[v[i].END][x] = f[x][v[i].END] = 1;
                Q.push(pair<int, int>(x, v[i].END));
            }
        }
    }
    return 0;
}

之后就是正解了
与20分的相似，还是先二分答案
定义$f[i][j]$为一个点在点$i$,一个点在边$j$上距离点$i$最近的那个点上是否可行
然后$f[i][j]<=1$要求$i$到$j$的最小距离小于二分的答案, 且存在某个$f[k][x]$为$1$,其中$k$是$j$的某个端点,$x$是某个以$i$为端点的边，或存在某个$f[t][j]$为$1$，其中$t$与$i$有边相连， $BFS$转移。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct Point
{
    double x, y;
    Point(double _x = 0, double _y = 0): x(_x), y(_y) {}
    Point operator - (const Point &a)
    {
        return Point(x - a.x, y - a.y);
    }
    double operator * (const Point &a)
    {
        return x * a.x + y * a.y;
    }
    double operator ^ (const Point &a)
    {
        return x * a.y - y * a.x;
    }
}a[1005];
int du[1005];
struct edge
{
    int S, END, next, id;
}v[2005];
int first[1005], p;
void add(int c, int b, int id)
{
    v[p].S = c;
    v[p].END = b;
    v[p].next = first[c];
    v[p].id = id;
    first[c] = p++;
}
double dis(const Point &x, const Point &y)
{
    return sqrt((x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y));
}
struct line
{
    Point a, b, c;
    double k;
    line() {}
    line(Point x, Point y) 
    {
        a = x, b = y;
        c = a - b;
        k = atan2(b.y - a.y, b.x - a.x);
    }
}l[1005];
double dis(Point &x, line &y)
{
    if ((y.c * (y.a - x)) * (y.c * (y.b - x)) <= 0)
        return abs((y.a - x) ^ (y.b - x)) / dis(y.a, y.b);
    return min(dis(y.a, x), dis(y.b, x));
}
bool f[1005][1005];
int n, stx, sty;
bool Judge(double mid)
{
    memset (f, 0, sizeof (f));
    queue<pair<int, int> > Q;
    for (int i = first[stx]; i != -1; i = v[i].next)
        f[sty][v[i].id] = 1, Q.push(pair<int, int>(sty, v[i].id));
    for (int i = first[sty]; i != -1; i = v[i].next)
        f[stx][v[i].id] = 1, Q.push(pair<int, int>(stx, v[i].id));
    while (!Q.empty())
    {
        pair<int, int> k = Q.front(); Q.pop();
        int x = k.first, y = k.second;
        for (int i = first[x]; i != -1; i = v[i].next)
        {
            if (!f[v[i].END][y] && dis(a[v[i].END], l[y]) <= mid)
            {
                f[v[i].END][y] = 1;
                Q.push(pair<int, int>(v[i].END, y));
            }
            if (!f[v[(y - 1) << 1].S][v[i].id] && dis(a[v[(y - 1) << 1].S], l[v[i].id]) <= mid)
            {
                f[v[(y - 1) << 1].S][v[i].id] = 1;
                Q.push(pair<int, int>(v[(y - 1) << 1].S, v[i].id));
            }
            if (!f[v[(y - 1) << 1].END][v[i].id] && dis(a[v[(y - 1) << 1].END], l[v[i].id]) <= mid)
            {
                f[v[(y - 1) << 1].END][v[i].id] = 1;
                Q.push(pair<int, int>(v[(y - 1) << 1].END, v[i].id));
            }
        }
    }
    for (int i = 1; i <= n; i++) if (du[i] == 1)
        for (int j = 1; j <= n; j++) if (du[j] == 1)
            if (f[i][v[first[j]].id] && dis(a[i], a[j]) <= mid)
                return 1;
    return 0;
}
int main()
{
    memset (first, -1, sizeof (first));
    n = read(), stx = read(), sty = read();
    for (int i = 1; i <= n; i++)
        a[i].x = read(), a[i].y = read();
    for (int i = 1; i < n; i++)
    {
        int b = read(), c = read();
        du[b]++, du[c]++;
        add(b, c, i);
        add(c, b, i);
        l[i] = line(a[b], a[c]);
    }
    double l = dis(a[stx], a[sty]), r = 1e9;
    while (abs(r - l) >= 1e-8)
    {
        double mid = (l + r) / 2;
        if (Judge(mid)) r = mid;
        else l = mid;
    }
    printf ("%.10f", l);
    // while (1);
}

C题先坑着，还不会做呢，过一段时间在填。

BZOJ1038 [ZJOI2008]瞭望塔

Fri, 09 Mar 2018 19:18:32 GMT

题目描述

致力于建设全国示范和谐小村庄的$H$村村长$dadzhi$，决定在村中建立一个瞭望塔，以此加强村中的治安。
我们将$H$村抽象为一维的轮廓。如下图所示

我们可以用一条山的上方轮廓折线$(x_1, y_1)$, $(x_2, y_2)$, $...$ $(x_n, y_n)$来描述H村的形状，这里$x_1 < x_2 < ... < x_n$。瞭望塔可以建造在$[x_1, x_n]$间的任意位置, 但必须满足从瞭望塔的顶端可以看到$H$村的任意位置。可见在不同的位置建造瞭望塔，所需要建造的高度是不同的。为了节省开支，$dadzhi$村长希望建造的塔高度尽可能小。

请你写一个程序，帮助$dadzhi$村长计算塔的最小高度。

输入格式：

输入文件$tower.in$第一行包含一个整数n，表示轮廓折线的节点数目。接下来第一行n个整数, 为$x_1 ~ x_n$. 第三行n个整数，为$y_1 ~ y_n$。

输出格式：

输出文件$tower.out$仅包含一个实数，为塔的最小高度，精确到小数点后三位。

Sample Input

6
1 2 4 5 6 7
1 2 2 4 2 1

Sample Output

1.000

题解

将所有的直线延长在上面做一个半平面交
答案一定取在直线的交点或下面山是顶点上

枚举半平面的每个交点向下做垂线，计算出他与山之间的距离
然后枚举山的每个顶点做垂线，计算出他与半平面之间的距离

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 305;
const double eps = 1e-20;
struct Point
{
    double x, y;
    Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
    Point operator - (const Point &a)
    {
        return Point(x - a.x, y - a.y);
    }
    double operator * (const Point &a) 
    {
        return x * a.y - y * a.x;
    }
}a[MAXN], c[MAXN];
struct line
{
    Point a, b;
    line(){}
    line(Point _a, Point _b)
    {
        a = _a;
        b = _b;
    }
    double k;
}l[MAXN];
bool cmp(line a, line b)
{
    if (a.k == b.k) return (b.a - a.a) * (b.b - a.a) >= eps;
    return a.k < b.k;
}
Point Get_Point(line a, line b)
{
    Point x;
    double dot1, dot2;
    dot1 = (b.a - a.a) * (b.b - a.a);
    dot2 = (b.b - a.b) * (b.a - a.b);
    x.x = (a.a.x * dot2 + a.b.x * dot1) / (dot1 + dot2);
    x.y = (a.a.y * dot2 + a.b.y * dot1) / (dot1 + dot2);
    return x;
}
bool Judge(line a, line b, line c)
{
    Point x = Get_Point(b, c);
    return (a.b - x) * (a.a - x) >= eps;
}
int Q[MAXN];
int main()
{
    int n = read();
    for (int i = 1; i <= n; i++)
        a[i].x = read();
    for (int i = 1; i <= n; i++)
        a[i].y = read();
    a[0].x = a[1].x - 1, a[0].y = 10000000;
    a[n + 1].x = a[n].x + 1, a[n + 1].y = 10000000;
    n++;
    for (int i = 1; i <= n; i++)
    {
        l[i].a = a[i - 1], l[i].b = a[i];
        l[i].k = atan2(a[i].y - a[i - 1].y, a[i].x - a[i - 1].x);
    }
    int cnt = 1;
    sort(l + 1, l + n + 1, cmp);
    for (int i = 2; i <= n; i++)
        if (l[i].k - l[i - 1].k >= eps)
            l[++cnt] = l[i];
    int h = 1, t = 2;
    Q[1] = 1, Q[2] = 2;
    for (int i = 3; i <= cnt; i++)
    {
        while (t > h && Judge(l[i], l[Q[t - 1]], l[Q[t]])) t--;
        while (t > h && Judge(l[i], l[Q[h + 1]], l[Q[h]])) h++;
        Q[++t] = i;
    }
    while (t > h && Judge(l[h], l[Q[t - 1]], l[Q[t]])) t--;
    while (t > h && Judge(l[t], l[Q[h + 1]], l[Q[h]])) h++;
    int tot = 0;
    for (int i = h + 1; i <= t; i++)
        c[++tot] = Get_Point(l[Q[i - 1]], l[Q[i]]);
    double ans = 1e60;
    for (int i = 1; i < n - 1; i++)
        for (int j = 1; j <= tot; j++)
            if (a[i].x <= c[j].x && c[j].x <= a[i + 1].x)
            {
                Point t(c[j].x, -1);
                ans = min(ans, c[j].y - Get_Point(line(a[i + 1], a[i]), line(c[j], t)).y);
            }
    for (int i = 1; i <= tot; i++)
        for (int j = 1; j < n; j++)
            if (c[i].x <= a[j].x && a[j].x <= c[i + 1].x)
            {
                Point t(a[j].x, -1);
                ans = min(ans, Get_Point(line(c[i], c[i + 1]), line(a[j], t)).y - a[j].y);
            }
    printf ("%.3f\n", ans);
    // while (1);
}

BZOJ1478/1815 Sgu282 Isomorphism/[Shoi2006]color 有色图

Tue, 06 Mar 2018 18:40:10 GMT

Description

给定一个$N$个结点的无向完全图（任意两个结点之间有一条边），现在你可以用 $M$ 种颜色对这个图的每条边进行染色，每条边必须染一种颜色。若两个已染色的图，其中一个图可以通过结点重新编号而与另一个图完全相同，就称这两个染色方案相同。现在问你有多少种本质不同的染色方法，输出结果 $mod P$。$P$ 是一个大于$N$的质数。

Input

仅一行包含三个数，$N$、$M$、$P$。

Output

仅一行，为染色方法数 $mod P$ 的结果。

Sample Input

3 4 97

Sample Output

题解

假定一个点置换，把它表示为循环，比如是$(a_1,a_2,....)(b_1,b_2...)(c_1,c_2...)...$

对于不在一个循环里面的点：比如$a1,b1$, 那么会有边循环$((a1,b1),(a2,b2)...)$设$a$循环的循环节是$l1,b$循环的循环节是$l2$,那么形成的边循环的循环节显然是$LCM(l1,l2)$。一共有$l1l2$个点对，每个点对都在一个循环节为$LCM(l1,l2)$的循环上，所以一共有$l1l2/LCM(l1,l2)=GCD(l1,l2)$个循环节，所以$C(f)=m^GCD(l1,l2)$。（回到$Burnside$引理，$C$为置换之后仍为本身的数目，就是说要循环节里的每条边都一样的颜色）
对于在一个循环里面的点：比如$a1$、$a2$。设这个$a$循环的循环节为$l1$。
- 如果$l1$是奇数，那么循环长度为$l1$，一共有$C(l1,2)$个点对，所以是$(l1-1)/2$个循环节，所以$C(f)=m^((l1-1)/2)$。
- 如果$l1$是偶数，除了上面这种情况之外，还有一种的循环节是$l1/2$（就是两个点刚好相隔半个周期，而边是双向的），所以一共有$(C(l1,2)-l1/2)/l1+1=l1/2$个点对。

整理一下：

$$C = \sum_{i = 1}^{k}{\lfloor \frac{L_i}{2} \rfloor} + \sum_{i = 1}^{k - 1}{\sum_{j = i + 1}^{k} {gcd(L_i, L_j)} }$$

$$S = \frac{ N! }{\prod_{i = 1} ^ {k} \times \prod_{i = 1}^{k}{ B_i! } }$$

$$Ans = Ans + S \times m^C$$

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int MOD;
const int MAXN = 1005;
int gcd(int a, int b)
{
    return b == 0 ? a : gcd(b, a % b);
}
int gd[MAXN][MAXN], f[MAXN];
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int l[MAXN];
long long ans;
int n, m;
void Get_Ans(int cnt)
{
    long long C = 0;
    for (int i = 1; i <= cnt; i++) C = (C + l[i] / 2) % MOD;
    for (int i = 1; i <= cnt; i++)
        for (int j = i + 1; j <= cnt; j++)
            C = (C + gd[l[i]][l[j]]) % MOD;
    long long now = 1, len = 0;
    for (int i = 1; i <= cnt; i++)
    {
        if (l[i] != l[i - 1])
        {
            now = now * f[len] % MOD;
            len = 0;
        }
        len++;
    }
    now = now * f[len] % MOD;
    for (int i = 1; i <= cnt; i++) now = now * l[i] % MOD;
    long long S = f[n] * pow_mod(now, MOD - 2) % MOD;
    ans = (ans + S * pow_mod(m, C) % MOD) % MOD;
}
void DFS(int cnt, int x, int les)
{
    if (les == 0) return Get_Ans(cnt);
    if (les < x) return;
    cnt++;
    while (x <= les)
    {
        l[cnt] = x;
        DFS(cnt, x, les - x);
        x++;
    }
}
int main()
{
    n = read(), m = read();
    MOD = read();
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            gd[i][j] = gcd(i, j);
    0[f] = 1;
    for (int i = 1; i <= n; i++)
        i[f] = 1ll * ((i - 1)[f]) * i % MOD;
    ans = 0;
    DFS(0, 1, n);
    printf ("%lld\n", ans * pow_mod(f[n], MOD - 2) % MOD);
}

BZOJ1547 周末晚会

Tue, 06 Mar 2018 17:30:33 GMT

Description

Irena和Sirup正准备下个周末的Party。为这个Party,他们刚刚买了一个非常大的圆桌。他们想邀请每个人，但他们现在不知道如何分配座次。Irena说当有超过K个女孩座位相邻（即这些女孩的座位是连续的，中间没有男孩）的话，她们就会说一整晚的话而不和其他人聊天。 Sirup没有其他选择，只有同意她。然而，作为一名数学家，他很快地痴迷于所有可能方案。题目说明： $N$个人围绕着圆桌坐着，其中一些是男孩，另一些是女孩。你的任务是找出所有合法的方案数，使得不超过$K$个女孩座位是连续的。循环同构会被认为是同一种方案。

Input

第一行有一个数$T$，表示以下有$T$组数据，每组数据有两个整数$N$，$K$。每组数据之间有一个空行隔开。

Output

输出$T$行，每行顺次对应一组测试数据。每组数据你需要输出最后的方案数除以$100000007$的余数。

Sample Input

Sample Output

2
4
3

解释：

第一组数据的方案是：$MMM$，$MMW$ ($M$是男孩, $W$是女孩)。
第二组数据的方案是：$MMM$，$MMW$，$MWW$，$WWW$。
第三组数据的方案是：$MMMM$, $MMMW$, $MWMW$。

约束和限制：

对于20%的数据$T <= 20$;
对于100%的数据$T <= 50$;
对于20%的数据$N,K <= 20$;
对于100%的数据$N,K < = 2000$;

题解

这又是一道$Burnside$的题目
首先这是一个环的旋转
对于每一个$N$，$K$ 都 $DP$ 一发算出$f[i][j]$表示$i$个人最后$j$个为女生,且合法的的方案数
然后枚举$gcd$的值x，这个值为循环节个数，这是可能的旋转次数为$\phi{(\frac{n}{i})}$
对于这个循环节个数，我们枚举他前后的女生数目的和
对于中间不是女生的我们强制第一个和最后一个为男生，乘上$DP$出的值
在乘上因为前后数目不同而形成的不同方案
就算完了一个

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MOD = 100000007;
int phi[2005], prime[2005], cnt;
bool isnprime[2005];
void Get_phi()
{
    isnprime[1] = 1;
    for (int i = 2; i <= 2000; i++)
    {
        if (!isnprime[i]) prime[++cnt] = i, phi[i] = i - 1;
        for (int j = 1; j <= cnt; j++)
        {
            if (i * prime[j] > 2000) break;
            isnprime[i * prime[j]] = 1;
            if (i % prime[j] == 0)
            {
                phi[i * prime[j]] = phi[i] * prime[j];
                break;
            }
            phi[i * prime[j]] = phi[i] * phi[prime[j]];
        }
    }
    phi[1] = 1;
}
long long DP[2005][2005];
int n, k;
long long Calc(int x)
{
    int m = min(x, k);
    long long ans = 0;
    for (int i = 0; i <= m; i++)
    {
        if (i != x) ans = (ans + DP[x - i - 1][0] * (i + 1) % MOD) % MOD;
        if (i == x && n <= k) ans = (ans + 1) % MOD;
    }
    return ans;
}
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int main()
{
    Get_phi();
    int T = read();
    while (T--)
    {
        n = read(), k = read();
        memset (DP, 0, sizeof (DP));
        DP[0][0] = 1;
        for (int i = 0; i < n; i++)
            for (int j = 0; j <= k; j++)
            {
                if (j < k) (DP[i + 1][j + 1] += DP[i][j]) %= MOD;
                (DP[i + 1][0] += DP[i][j]) %= MOD;
            }
        long long ans = 0;
        for (int i = 1; i * i <= n; i++)
            if (n % i == 0)
            {
                ans = (ans + Calc(i) * phi[n / i] % MOD) % MOD;
                if (i * i != n) ans = (ans + Calc(n / i) * phi[i] % MOD) % MOD;
            }
        printf ("%d\n", ans * pow_mod(n, MOD - 2) % MOD);
    }
}

BZOJ1004 [HNOI2008] Cards

Mon, 05 Mar 2018 21:13:22 GMT

Description

小春现在很清闲,面对书桌上的N张牌,他决定给每张染色,目前小春只有$3$种颜色:红色,蓝色,绿色.他询问 Sun 有多少种染色方案, Sun 很快就给出了答案.进一步,小春要求染出$Sr$张红色,$Sb$张蓝色,$Sg$张绝色.他又询问有多少种方案, Sun 想了一下,又给出了正确答案. 最后小春发明了$M$种不同的洗牌法,这里他又问 Sun 有多少种不同的染色方案.两种染色方法相同当且仅当其中一种可以通过任意的洗牌法(即可以使用多种洗牌法,而每种方法可以使用多次)洗成另一种. Sun 发现这个问题有点难度,决定交给你,答案可能很大,只要求出答案除以$P$的余数($P$为质数).

Input

第一行输入 $5$ 个整数：$Sr,Sb,Sg,m,p(m<=60,m+1<p<100)$。$n=Sr+Sb+Sg$。
接下来 $m$ 行，每行描述一种洗牌法，每行有 n 个用格隔开的整数 $X_1 X_2...X_n$，恰为 $1$ 到 $n$ 的一个排列，表示使用这种洗牌法，第 $i$ 位变为原来的 $X_i$ 位的牌。输入数据保证任意多次洗牌都可用这 $m$ 种洗牌法中的一种代替，且对每种洗牌法，都存在一种洗牌法使得能回到原状态。

Output

不同染法除以$P$的余数

Sample Input

1 1 1 2 7
2 3 1
3 1 2

Sample Output

HINT

有 $2$ 种本质上不同的染色法 $RGB$ 和 $RBG$，使用洗牌法 $231$ 一次可得 $GBR$ 和 $BGR$ ，使用洗牌法 $312$ 一次可得 $BRG$ 和 $GRB$。
$100%$ 数据满足 $Max{Sr,Sb,Sg}<=20$。

题解

一道比较基础的$Burnside$题目
这里先介绍一下$Burnside$定理
设$D(a_j)$为在置换$a_j$下不变的元素的个数。 $L$表示本质不同的方案数
则$$L = \frac{1}{|G|}\sum_{j = 1}^{|G|}{D(a_j)}$$

在本题中
我们群的大小为$m+1$
对于每一个置换，我们都可以求出它不变的元素个数
首先求出所有的环，因为我们的环上必须是同一种颜色才能使他这个元素在置换下不变(这里把涂色方案看做是一个元素)
我们求出所有环之后就可以$DP$出方案的个数

!要注意如果要使所有的洗牌法构成一个群，我们必须有一个单位元，也就是存在一个置换使得任意一个置换与他运算完不变
在本题中显然是一下$i->i$的的置换，但这个置换不是读入的，而是要自己加上去的。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int MOD; 
const int MAXN = 65;
int a[MAXN];
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int vis[MAXN], st[MAXN];
int dfs(int x, int C)
{
    if (vis[x] == C) return 0;
    vis[x] = C;
    return dfs(a[x], C) + 1;
}
int DP[2][25][25][25];
int main()
{
    int Sr = read(), Sb = read(), Sg = read(), m = read();
    MOD = read();
    int n = Sr + Sb + Sg;
    int Ans = 0;
    memset (vis, -1, sizeof (vis));
    for (int i = 0; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
            a[j] = (i == 0 ? (j) : read());
        int cnt = 0;
        for (int j = 1; j <= n; j++)
            if (vis[j] != i)
                st[++cnt] = dfs(j, i);
        memset (DP, 0, sizeof (DP));
        DP[0][Sr][Sb][Sg] = 1;
        int now = 0;
        for (int j = 1; j <= cnt; j++)
        {
            now ^= 1;
            memset(DP[now], 0, sizeof (DP[now]));
            for (int r = 0; r <= Sr; r++)
                for (int b = 0; b <= Sb; b++)
                    for (int g = 0; g <= Sg; g++)
                    {
                        if (r + st[j] <= Sr) DP[now][r][b][g] = (DP[now][r][b][g] + DP[now ^ 1][r + st[j]][b][g]) % MOD;
                        if (b + st[j] <= Sb) DP[now][r][b][g] = (DP[now][r][b][g] + DP[now ^ 1][r][b + st[j]][g]) % MOD;
                        if (g + st[j] <= Sg) DP[now][r][b][g] = (DP[now][r][b][g] + DP[now ^ 1][r][b][g + st[j]]) % MOD;
                    }
        }
        Ans = (DP[now][0][0][0] + Ans) % MOD;
    }
    printf ("%d\n", 1ll * Ans * pow_mod(m + 1, MOD - 2) % MOD);
}

UOJ182 【UR #12】a^-1 + b problem

Thu, 01 Mar 2018 06:08:11 GMT

在你的帮助下，跳蚤国王终于打开了最后一间房间的大门。然而，picks 博士和他的猴子们早已通过地道逃跑了。万幸的是，因为阿姆斯特朗回旋加速喷气式阿姆斯特朗炮本身太过笨重，无法从地道中运走，所以还被静静的停放在房间的正中央。
拥有了征服世界的力量，跳蚤国王感觉非常一颗赛艇。为了试验这个传说中的武器的威力，跳蚤国王让士兵们把炮口对准空无一人的实验室开炮。
然而，事情总是没有这么顺利。片刻之后，一个士兵匆匆跑到跳蚤国王身前：“报！picks 博士给它设置了保险！但是我们根本不知道解除方法！”
经过研究，跳蚤国王发现，picks 博士所设置的保险措施可以简化为这样一个问题：
首先炮身的屏幕上显示了 $n$ 个数，接着在模 $998244353(7\times 17 \times 2^{23}+1$，一个质数) 意义下，给出了 $m$ 条指令，每一条指令都是下列两种之一：

给所有数加上某一个数。
让所有数都变成原来的逆元。（保证这时所有数的逆元都存在）

在每个指令完成之后，你要回答当前屏幕上所有数的和。
跳蚤国王思索了片刻，发现这个问题奥妙重重，于是他让你——这附近最著名的民间科学家来帮他解决这个难题。

输入格式

第一行两个正整数 $n,m$，含义如题意所述。

第二行$n$个数，表示屏幕上最初显示的 $n$ 个数。

接下来$m$行，表示 $m$ 条指令，第 $i$ 行第一个数$t_i$表示第 $i$ 个操作的类型。

若 $t_i=1$ 则接下来有一个整数 $x_i$，表示给所有数都加上 $x_i$。

若 $t_i=2$ 则表示将所有数都变成原来的逆元。

输出格式

输出$m$行，第$i$行一个整数表示第$i$条指令之后当前屏幕上每个数的和。

样例一

input

output

explanation

执行每个指令后的数列分别如下：

2 3 4 5 6
499122177 332748118 748683265 598946612 166374059
499122178 332748119 748683266 598946613 166374060
665496236 249561089 399297742 831870295 142606337
499122178 332748119 748683266 598946613 166374060

限制与约定

<table class="table table-bordered table-text-center table-vertical-middle"><thead><tr><th>测试点编号</th><th>限制与约定</th></tr></thead><tbody><tr><td>1</td><td rowspan="1">$n, m \leq 1000$</td></tr><tr><td>2</td><td rowspan="1">$n \leq 100000$, $m \leq 60000$, $t_i = 1$</td></tr><tr><td>3</td><td rowspan="1">$n, m \leq 10000$</td></tr><tr><td>4</td><td rowspan="1">$n, m \leq 20000$</td></tr><tr><td>5</td><td rowspan="1">$n, m \leq 30000$</td></tr><tr><td>6</td><td rowspan="2">$n \leq 100000$, $m \leq 30000$</td></tr><tr><td>7</td></tr><tr><td>8</td><td rowspan="3">$n \leq 100000$, $m \leq 60000$</td></tr><tr><td>9</td></tr><tr><td>10</td></tr></tbody></table>

对于所有数据$1 \le n \le 100000$，$1 \le m \le 60000$, $t_i \in {1, 2}$其他所有数均为区间中的整数。

保证任何时候每个数的逆元均存在。

时间限制：$4s$ 空间限制：$256MB$

题解

出门左拐UOJ; 那一毫秒的距离

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 1e6 * 4;
const int MOD  = 998244353;
const int L = (1 << 18) + 1;
const int LM = (1 << 16) + 1;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int N, Inv, rev[MAXN];
int Sum = 0, n, m;
struct data
{
    int e, f, g, id;
}s[60005];
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int ans[MAXN], cnt;
void insert(int a, int b, int c, int d, int id)
{
    if (b == 0)
    {
        ans[id] = ((1ll * a * Sum) + (1ll * c * n)) % MOD * pow_mod(d, MOD - 2) % MOD;
        return;
    }
    s[++cnt].f = (1ll * b * c - 1ll * a * d) % MOD;
    b = pow_mod(b, MOD - 2);
    s[cnt].e = 1ll * a * b % MOD, s[cnt].g = 1ll * d * b % MOD;
    b = 1ll * b * b % MOD; s[cnt].f = 1ll * s[cnt].f * b % MOD;
    if (s[cnt].f < 0) s[cnt].f += MOD;
    s[cnt].id = id;
}
void Init(int x)
{
    N = 1;
    while (N < (x << 1)) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
}
inline int Calc(int x)
{
    N = 1;
    while (N < (x << 1)) N <<= 1;
    return N;
}
void FFt(int *a, int op)
{
    int w, wn, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = 1ll * w * wn % MOD)
            {
                t = 1ll * a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = 1ll * a[i] * Inv % MOD;
}
int tmp[MAXN], x[MAXN];
void Get_Inv(int *a, int *b, int n)
{
    if (n == 1) return b[0] = pow_mod(a[0], MOD - 2), void();
    Get_Inv(a, b, n + 1 >> 1);
    Init(n);
    for (int i = 0; i < n; i++) tmp[i] = a[i];
    for (int i = n; i < N; i++) tmp[i] = 0;
    FFt(tmp, 1), FFt(b, 1);
    for (int i = 0; i < N; i++) 
        b[i] = 1ll * b[i] * ((2 - 1ll * b[i] * tmp[i] % MOD + MOD) % MOD) % MOD;
    FFt(b, -1);
    for (int i = n; i < N; i++) b[i] = 0;
}
int Get_mod(int *a, int ra, int *b, int rb, int *c)
{
    while (ra && !a[ra - 1]) --ra;
    while (rb && !b[rb - 1]) --rb;
    if (ra < rb)
    {
        memcpy (c, a, ra << 2);
        memset (c + ra, 0, (rb - ra) << 2);
        return rb;
    }
    static int tmp1[MAXN], tmp2[MAXN];
    int rc = ra - rb + 1;
    int l = Calc(rc);
    for (int i = 0; i < l; i++) tmp1[i] = 0;
    reverse_copy(b, b + rb, tmp1);
    for (int i = 0; i < l; i++) tmp2[i] = 0;
    // for (int i = 0; i < rb; i++) printf ("1: %d, tmp1: %d\n", rb, tmp1[i]);    
    Get_Inv(tmp1, tmp2, rc);
    for (int i = rc; i < l; i++) tmp2[i] = 0;
    reverse_copy(a, a + ra, tmp1);
    for (int i = rc; i < l; i++) tmp1[i] = 0;
    Init(rc), FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1);
    // for (int i = 0; i < rb; i++) printf ("2: %d, tmp1: %d\n", rb, tmp1[i]);    
    reverse(tmp1, tmp1 + rc);
    // for (int i = 0; i < rb; i++) printf ("3: %d, tmp1: %d\n", rb, tmp1[i]);    
    Init(ra);
    for (int i = 0; i < rb; i++) tmp2[i] = b[i];
    for (int i = rb; i < N; i++) tmp2[i] = 0;
    for (int i = rc; i < N; i++) tmp1[i] = 0;
    FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1);
    // for (int i = 0; i < rb; i++) printf ("4: %d, tmp1: %d\n", rb, tmp1[i]);
    for (int i = 0; i < rb; i++) c[i] = (a[i] - tmp1[i] + MOD) % MOD;
    for (int i = rb; i < N; i++) c[i] = 0;
    // for (int i = 0; i < rb; i++) printf ("C: %d, %d\n", rb, c[i]);
    while (rb && !c[rb - 1]) --rb;
    return rb;
}
int Solve0(int *a, int l, int r)
{
    int ra = r - l + 2;
    if (ra <= 256)
    {
        memset(a, 0, ra << 2), a[0] = 1;
        for (int i = l; i <= r; i++)
            for (int v = x[i], j = i - l; j != -1; j--)
            {
                a[j + 1] = (a[j + 1] + a[j]) % MOD;
                a[j] = 1ll * a[j] * v % MOD;
            }
        return ra;
    }
    int mid = l + r >> 1;
    int *f1 = a, r1 = Solve0(f1, l, mid);
    int *f2 = a + r1, r2 = Solve0(f2, mid + 1, r);
    N = 1;
    while (N < ra) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    static int tmp1[L], tmp2[L];
    memcpy(tmp1, f1, r1 << 2), memset (tmp1 + r1, 0, (N - r1) << 2), FFt(tmp1, 1);
    memcpy(tmp2, f2, r2 << 2), memset (tmp2 + r2, 0, (N - r2) << 2), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) a[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(a, -1);
    return ra;
}
int *p[L];
int sta[MAXN];
int mem[LM << 4], *head = mem;
inline int Solve1(int id, int l, int r)
{
    int ra = r - l + 2;
    if (ra <= 256)
    {
        int *f = p[id] = head; head += ra;
        memset (f, 0, ra << 2), 0[f] = 1;
        for (int i = l; i <= r; i++)
            for (int v = (MOD - sta[i]) % MOD, j = i - l; j != -1; j--)
                f[j + 1] = (f[j + 1] + f[j]) % MOD, f[j] = 1ll * f[j] * v % MOD;
        return ra;
    }
    int mid = l + r >> 1;
    int r1 = Solve1(id << 1, l, mid), *f1 = p[id << 1];
    int r2 = Solve1(id << 1 | 1, mid + 1, r), *f2 = p[id << 1 | 1];
    N = 1;
    while (N < ra) N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    static int tmp1[LM], tmp2[LM];
    memcpy(tmp1, f1, r1 << 2), memset (tmp1 + r1, 0, (N - r1) << 2), FFt(tmp1, 1);
    memcpy(tmp2, f2, r2 << 2), memset (tmp2 + r2, 0, (N - r2) << 2), FFt(tmp2, 1);
    int *f = p[id] = head; head += ra;
    for (int i = 0; i < N; i++) f[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(f, -1);
    return ra; 
}
int val0[LM], val[LM];
void Solve2(int id, int *a, int *b, int l, int r, int deg)
{
    int ra = r - l + 2;
    if (deg <= 256)
    {
        int F, G;
        for (int i = l; i <= r; i++)
        {
            F = G = 0;
            int u = sta[i], v = 1;
            for (int j = 0; j <= deg; j++)
            {
                F = (F + 1ll * v * a[j]) % MOD;
                G = (G + 1ll * v * b[j]) % MOD;
                v = 1ll * v * u % MOD;
            }
            val0[i] = F, val[i] = G;
        }
        return;
    }
    int mid = l + r >> 1;
    int r1 = Get_mod(a, deg, p[id], ra, a + deg); a += deg;
    int r2 = Get_mod(b, deg, p[id], ra, b + deg); b += deg;
    ra = min(r1, r2);
    Solve2(id << 1, a, b, l, mid, ra), Solve2(id << 1 | 1, a, b, mid + 1, r, ra);
}
int g[MAXN], h[MAXN];
int main()
{
    // freopen ("1.in", "r", stdin);
    // freopen ("1.out", "w", stdout);
    n = read(), m = read();
    Sum = 0;
    for (int i = 1; i <= n; i++)
        x[i] = read() % MOD, Sum = (Sum + x[i]) % MOD;
    int A = 1, B = 0, C = 0, D = 1;
    for (int i = 1; i <= m; i++)
    {
        if (read() == 1)
        {
            int v = read() % MOD;
            A = (A + 1ll * v * B % MOD) % MOD;
            C = (C + 1ll * v * D % MOD) % MOD;
            insert(A, B, C, D, i);
        }
        else
        {
            swap(A, B);
            swap(C, D);
            insert(A, B, C, D, i);
        }
    }
    if (cnt)
    {
        for (int i = 1; i <= cnt; i++) sta[i] = s[i].g;
        sort(sta + 1, sta + cnt + 1);
        int lenth = unique(sta + 1, sta + cnt + 1) - sta - 1;
        for (int i = 1; i <= cnt; i++)
            s[i].g = lower_bound(sta + 1, sta + lenth + 1, s[i].g) - sta;
        Solve0(g, 1, n);
        for (int i = 1; i <= n; i++) h[i - 1] = 1ll * g[i] * i % MOD;
        Solve1(1, 1, lenth);
        Solve2(1, g, h, 1, lenth, n + 1);
        for (int i = 1; i <= cnt; i++)
            ans[s[i].id] = (1ll * s[i].e * n % MOD + 1ll * s[i].f * val[s[i].g] % MOD * pow_mod(val0[s[i].g], MOD - 2) % MOD) % MOD;
    }
    for (int i = 1; i <= m; i++)
        printf ("%d\n", ans[i]);
    // while (1);
}

UOJ50 【UR #3】链式反应

Wed, 28 Feb 2018 19:04:10 GMT

<p>著名核物理专家 Picks 最近发现了一种非常适合核裂变的元素叫囧元素。囧元素原子序数为 1024，囧-2333 如果被一个中子撞击后会分裂成蒟-1234 和蒻-1098 同时<strong>释放出恰好 $2$ 个中子</strong>，并且<strong>以破坏死光的方式释放光子</strong>。</p> <p>核物理专家 Picks 做实验从来不用实验仪器。他用手指从宇宙中挑选出了 $n$ 个囧-2333 原子并编号为 $1$ 到 $n$，并用帅气的眼神发射中子撞击了编号为 $1$ 的囧原子，启动了链式反应。</p> <p>当一个囧-2333原子被中子撞击时，有两种情况。要么这个囧-2333原子变为了囧-2334 并不再参与后续反应，要么囧-2333会进行核裂变，一方面，裂变产生的破坏死光会<strong>照射到 $c$ 个不同的囧-2333原子</strong>并且这些原子会极为神奇地分解为氢和氦的混合物并不再参与后续反应。另一方面，裂变后产生的 $2$ 个中子会<strong>分别撞上两个不同的囧-2333原子</strong>。显然被破坏死光照射后就不是囧-2333了，所以不可能又被中子撞上又被破坏死光照射到。</p> <p>经过反复实验，核物理专家 Picks 终于确定了 $c$ 的范围 $A$，其中 $A$ 是一个非负整数集合。每次破坏死光会照射并影响到的囧-2333原子数量 $c$ 满足 $c \in A$ 。</p> <p>链式反应时 Picks 会用肉眼观察实验中出现的事件（仅包括中子的撞击和破坏死光的信息），结束后 Picks 会写下实验记录。</p> <p>但是很不幸 Picks 的实验记录丢失了。他只记得链式反应后<strong>没有剩余的囧-2333原子</strong>，而且每次一个囧-2333原子核裂变时，中子总是撞击<strong>编号比它大的囧-2333原子</strong>，破坏死光也总是照射<strong>编号比它大的囧-2333原子</strong>。</p> <p>求可能会有多少种不同的实验记录。你需要对于 $n = 1, \dots, n_{max}$ 输出答案。你只用输出答案对 $998244353$（$7 \times 17 \times 2^{23} + 1$，一个质数）取模后的值。</p> <p>两个实验记录 $T_1$，$T_2$ 被认为是相同的当且仅当：</p> <ol><li>“编号为 $v$ 的囧-2333分裂产生的中子撞上了编号为 $u$ 的囧-2333” 这个事件在 $T_1$ 中当且仅当这个事件在 $T_2$ 中。</li> <li>“编号为 $v$ 的囧-2333分裂产生的破坏死光照射了编号为 $u$ 的囧-2333” 这个事件在 $T_1$ 中当且仅当这个事件在 $T_2$ 中。</li> </ol><h3>输入格式</h3> <p>第一行一个正整数 $n_{max}$。</p> <p>第二行是一个长度为 $n_{max}$ 的01字符串。如果把字符从 $0$ 开始编号，那么第 $i$ 个字符为 $0$ 表示 $i$ 不在集合 $A$ 内，否则表示 $i$ 在集合 $A$ 内。</p> <h3>输出格式</h3> <p>$n_{max}$ 行，如果把行从 $1$ 开始编号，那么第 $i$ 行表示 $n = i$ 时该问题的答案。</p> <h3>样例一</h3> <h4>input</h4>

5
10100

output

<h4>explanation</h4> <p>$n = 1$ 时，只有一种实验记录。</p> <p>$n = 2$ 时，没有可能的实验记录。</p> <p>$n = 3$ 时，唯一可能的实验记录为：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> </ul><p>$n = 4$ 时，没有可能的实验记录。</p> <p>$n = 5$ 时，有十种可能的实验记录。第一种是：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $4$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $5$ 的囧-2333。</li> </ul><p>第二种是：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $4$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $5$ 的囧-2333。</li> </ul><p>第三种是：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $5$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> <li>编号为 $2$ 的囧-2333分裂产生的中子撞上了编号为 $4$ 的囧-2333。</li> </ul><p>第四种是：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> <li>编号为 $3$ 的囧-2333分裂产生的中子撞上了编号为 $4$ 的囧-2333。</li> <li>编号为 $3$ 的囧-2333分裂产生的中子撞上了编号为 $5$ 的囧-2333。</li> </ul><p>第五种是：</p> <ul><li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $2$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的中子撞上了编号为 $3$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的破坏死光照射了编号为 $4$ 的囧-2333。</li> <li>编号为 $1$ 的囧-2333分裂产生的破坏死光照射了编号为 $5$ 的囧-2333。</li> </ul><p>第六种到第十种均与第五种类似。空白太小我就不演示了。</p> <h3>样例二</h3> <h4>input</h4>

8
10000000

<h4>output</h4>

<h3>样例三</h3> <p>见样例数据下载</p> <h3>样例四</h3> <p>见样例数据下载</p> <h3>限制与约定</h3> <div class="table-responsive"> <table class="table table-bordered table-text-center table-vertical-middle"><thead><tr><th>测试点编号</th> <th>$n$</th> </tr></thead><tbody><tr><td>1</td><td>$n \leq 8$</td></tr><tr><td>2</td><td>$n \leq 100$</td></tr><tr><td>3</td><td>$n \leq 100$</td></tr><tr><td>4</td><td>$n \leq 200$</td></tr><tr><td>5</td><td>$n \leq 5000$</td></tr><tr><td>6</td><td>$n \leq 5000$</td></tr><tr><td>7</td><td>$n \leq 50000$</td></tr><tr><td>8</td><td>$n \leq 50000$</td></tr><tr><td>9</td><td>$n \leq 70000$</td></tr><tr><td>10</td><td>$n \leq 200000$</td></tr></tbody></table></div> <p><strong>时间限制：</strong>$4\texttt{s}$</p> <p><strong>空间限制：</strong>$256\texttt{MB}$</p> <h3>下载</h3> <p><a href="/download.php?type=problem&id=50">样例数据下载</a></p>

题解

设$f[i]$为$n$个节点的树的方案数$f[1] = 1$
我们设两个中子打中的子树大小为j,k
则答案为$f[n] = \sum_{j}\sum_{k}C_{n - 1}^{j}C_{n - 1 - j}^{k}*f[j]*f[k]$
然后DP有40分

#include <cstdio>
#include <cstring>
#include <algorithm>
# define int long long 
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 1000;
const int MOD = 998244353;
char s[MAXN];
int F[MAXN];
int c[MAXN][MAXN];
int Inv2 = 499122177;
int DP(int x)
{
    if (F[x] != -1) return F[x];
    if (x == 1) return F[x] = 1;
    else F[x] = 0;
    for (int i = 1; i <= x; i++)
        for (int j = 1; j <= x; j++)
            if (x - 1 - i - j >= 0 && s[x - 1 - i - j])
                (F[x] += 1ll * DP(i) * DP(j) % MOD * c[x - 1][i] % MOD * c[x - 1 - i][j] % MOD * Inv2 % MOD) %= MOD;
    return F[x];
}
signed main()
{
    int n = read();
    scanf ("%s", s);
    for (int i = 0; i < n; i++) s[i] -= '0';
    c[0][0] = 1;
    for (int i = 1; i <= n; i++)
    {
        c[i][0] = 1;
        for (int j = 1; j <= n; j++)
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
    }
    memset (F, -1, sizeof (F));
    for (int i = 1; i <= n; i++) 
        printf ("%d\n", DP(i));
    return 0;
}

建立生成函数
设$f(x)$为答案的生成函数
设$g(x)$为限制条件的生成函数
则$f'(x)=\frac{1}{2}f^{2}(x)g(x)+1$
可以CDQ+FFT用$0 \cdots n-1$的$f$来更新$f(n)$
时间复杂度$O(n\log^{2}{n})$

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 200005 * 4;
const int MOD = 998244353;
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
char s[MAXN];
int F[MAXN], FInv[MAXN];
int g[MAXN], f[MAXN], h[MAXN];
int N, Inv;
int rev[MAXN];
int tmp1[MAXN], tmp2[MAXN];
int Init(int x)
{
    N = 1;
    while (N < (x << 1)) N <<= 1;
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    Inv = pow_mod(N, MOD - 2);
}
void FFt(int *a, int op)
{
    int w, wn, t;
    for (int i = 1; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = 1ll * w * wn % MOD)
            {
                t = 1ll * a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = 1ll * a[i] * Inv % MOD;
}
void Solve(int l, int r)
{
    if (l == r) return;
    int mid = l + r >> 1;
    Solve(l, mid);
    Init(r - l + 1);
    memset (tmp1, 0, N << 2);
    memset (tmp2, 0, N << 2);
    for (int i = l; i <= mid; i++) tmp1[i - l] = f[i];
    for (int i = 0; i <= r - l; i++)
        if (i < l) tmp2[i] = 2 * f[i] % MOD;
        else if (i <= mid) tmp2[i] = f[i];
    FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1);
    for (int i = mid + 1; i <= r; i++) h[i] = (h[i] + tmp1[i - l]) % MOD;
    memset (tmp1, 0, N << 2);
    memset (tmp2, 0, N << 2);
    for (int i = l; i <= mid; i++) tmp1[i - l] = h[i];
    for (int i = 0; i <= r - l; i++) tmp2[i] = g[i];
    FFt(tmp1, 1), FFt(tmp2, 1);
    for (int i = 0; i < N; i++) tmp1[i] = 1ll * tmp1[i] * tmp2[i] % MOD;
    FFt(tmp1, -1);
    for (int i = mid + 1; i <= r; i++) f[i] = (f[i] + 1ll * tmp1[i - l - 1] * F[i - 1] % MOD * FInv[i] % MOD) % MOD;
    Solve(mid + 1, r);
}
int main()
{
    int n = read();
    scanf ("%s", s);
    for (int i = 0; i < n; i++) s[i] -= '0';
    F[0] = 1;
    for (int i = 1; i <= n; i++) F[i] = 1ll * F[i - 1] * i % MOD;
    FInv[n] = pow_mod(F[n], MOD - 2);
    for (int i = n - 1; i >= 0; i--) FInv[i] = 1ll * FInv[i + 1] * (i + 1) % MOD;
    for (int i = 0; i < n; i++) g[i] = 1ll * s[i] * FInv[i] * FInv[2] % MOD;
    f[1] = 1;
    Solve(1, n);
    for (int i = 1; i <= n; i++)
        printf ("%d\n", 1ll * f[i] * F[i] % MOD);
}

BZOJ3684: 大朋友和多叉树

Mon, 26 Feb 2018 08:52:23 GMT

Description

我们的大朋友很喜欢计算机科学，而且尤其喜欢多叉树。对于一棵带有正整数点权的有根多叉树，如果它满足这样的性质，我们的大朋友就会将其称作神犇的：点权为1的结点是叶子结点；对于任一点权大于1的结点u，u的孩子数目deg[u]属于集合D，且u的点权等于这些孩子结点的点权之和。给出一个整数s，你能求出根节点权值为s的神犇多叉树的个数吗？请参照样例以更好的理解什么样的两棵多叉树会被视为不同的。我们只需要知道答案关于950009857（453*2^21+1，一个质数）取模后的值。

Input

第一行有2个整数s,m。第二行有m个互异的整数，d[1],d[2],…,d[m]，为集合D中的元素。

Output

输出一行仅一个整数，表示答案模950009857的值。

Sample Input

4 2
2 3

Sample Output

HINT

数据规模： $1 \leq m < s \leq 10^5$, $2 \leq d[i] \leq s$，有3组小数据和3组大数据。

题解

求出树的生成函数$T(x) = \sum_{i\ge 0} t_ix^i$ $$T(x) = x + \sum_{k \in S}T(x)^k$$

移一下项 $$T(x) - \sum_{k \in S}T(x)^k = x$$

设$G(y) = y - \sum_{k \in S}{y^k}$

$$x = G(T(x))$$

$T(x)$为$G(x)$的复合逆

上拉格朗日反演

$$ [x^n]T(x) = \frac{1}{n}[x^{n-1}] ( \frac {x}{G(x)} )^n $$

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MOD = 950009857;
const int MAXN = 2e6 + 5;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
int rev[MAXN];
int Inv;
void FFt(int *a, int N, int op)
{
    int w, wn, t;
    for (int i = 1; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(7, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = 1ll * w * wn % MOD)
            {
                t = 1ll * a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = 1ll * a[i] * Inv % MOD;
}
int tmp[MAXN];
void Get_Inv(int dep, int *a, int *b)
{
    if (dep == 1) return b[0] = pow_mod(a[0], MOD - 2), void();
    Get_Inv((dep + 1) >> 1, a, b);
    int N = 1;
    while (N < (dep << 1))
        N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    //copy(a, a + dep, tmp);
    for (int i = 0; i < dep; i++)
        tmp[i] = a[i];
    for (int i = dep; i < N; i++)
        tmp[i] = 0;
    //fill(tmp + dep, tmp + N, 0);
    FFt(tmp, N, 1);
    FFt(b, N, 1);
    for (int i = 0; i < N; i++)
        b[i] = 1ll * b[i] * ((2 - 1ll * b[i] * tmp[i] % MOD + MOD) % MOD) % MOD;
    FFt(b, N, -1);
    for (int i = dep; i < N; i++)
        b[i] = 0;
    //fill(b + dep, b + N, 0);
}
int G[MAXN], Ans[MAXN], C[MAXN];
int main()
{
    int n = read(), m = read();
    C[0] = 1;
    for (int i = 1; i <= m; i++)
        C[read() - 1] = MOD - 1;
    Get_Inv(n, C, G);
    Ans[0] = 1;
    int b = n;
    int N = 1;
    while (N < 2 * n)
        N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    while (b)
    {
        if (b & 1)
        {
            FFt(Ans, N, 1);
            FFt(G, N, 1);
            for (int i = 0; i < N; i++) Ans[i] = 1ll * Ans[i] * G[i] % MOD;
            FFt(Ans, N, -1);
            FFt(G, N, -1);
            for (int i = n; i < N; i++)
                Ans[i] = 0;
        }
        b >>= 1;
        FFt(G, N, 1);
        for (int i = 0; i < N; i++) G[i] = 1ll * G[i] * G[i] % MOD;
        FFt(G, N, -1);
        for (int i = n; i < N; i++)
            G[i] = 0;
        // fill(G + n, G + N, 0);
    }
    printf ("%d\n", 1ll * Ans[n - 1] * pow_mod(n, MOD - 2) % MOD);
}

BZOJ3456: 城市规划

Mon, 26 Feb 2018 08:10:23 GMT

Description

刚刚解决完电力网络的问题, 阿狸又被领导的任务给难住了. 刚才说过, 阿狸的国家有n个城市, 现在国家需要在某些城市对之间建立一些贸易路线, 使得整个国家的任意两个城市都直接或间接的连通. 为了省钱, 每两个城市之间最多只能有一条直接的贸易路径. 对于两个建立路线的方案, 如果存在一个城市对, 在两个方案中是否建立路线不一样, 那么这两个方案就是不同的, 否则就是相同的. 现在你需要求出一共有多少不同的方案. 好了, 这就是困扰阿狸的问题. 换句话说, 你需要求出n个点的简单(无重边无自环)无向连通图数目. 由于这个数字可能非常大, 你只需要输出方案数mod 1004535809(479 * 2 ^ 21 + 1)即可.

Input

仅一行一个整数n(<=130000)

Output

仅一行一个整数, 为方案数 mod 1004535809.

Sample Input

Sample Output

HINT

对于 100%的数据, n <= 130000

题解

设无向图的生成函数为$G(x)$, 无向联通图的生成函数为$f(x)$ $$g(x) = 2^{C_n^2}$$ 枚举无向图是由几个联通图构成的: $$g(n) = \sum_{i = 1}^{n} { {n - 1} \choose {i - 1} } f(i) G(n - i)$$ $$2^{n \choose 2} = \sum_{i = 1}^{n} { {n - 1} \choose {i - 1} } f(i) 2^{ {n - i} \choose 2}$$ 然后两边同时除以 $$(n-1)!$$ $$\frac{2^{n \choose 2} }{(n-1)!} = \sum_{i = 1}^{n} \frac{f(i)}{(i-1)!} \frac{2^{ {n - i} \choose 2} }{(n-i)!}$$

定义函数 $F(x),G(x),C(x)$

$$F(x) = \sum_{n=1}^{\infty} \frac{f(n)}{(n-1)!}x^n$$
$$G(x) = \sum_{n=0}^{\infty} \frac{2^{n \choose 2} }{n!}x^n $$ $$C(x) = \sum_{n=0}^{\infty} \frac{2^{n \choose 2} }{(n-1)!}x^n$$

$$C(x) = F(x)G(x)$$

$$C(x) \equiv F(x)G(x) mod { x^{n+1} }$$

$$F(x) \equiv C(x)G^{-1}(x) mod { x^{n+1} }$$

多项式求逆

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MOD = 1004535809;
const int MAXN = 1 << 18 + 1;
long long pow_mod(long long a, int b)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
long long Inv;
int N;
int rev[MAXN];
void FFt(long long *a, int op)
{
    long long w, wn, t;
    for (int i = 1; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = w * wn % MOD)
            {
                t = a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = a[i] * Inv % MOD;
}
long long tmp[MAXN];
void Get_Inv(int dep, long long *a, long long *b)
{
    if (dep == 1)
        return b[0] = pow_mod(a[0], MOD - 2), void();
    Get_Inv((dep + 1) >> 1, a, b);
    N = 1;
    while (N < (dep << 1))
        N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    copy(a, a + dep, tmp);
    fill(tmp + dep, tmp + N, 0);
    FFt(tmp, 1);
    FFt(b, 1);
    for (int i = 0; i < N; i++)
        b[i] = b[i] * ((2 - b[i] * tmp[i] % MOD + MOD) % MOD) % MOD;
    FFt(b, -1);
    fill(b + dep, b + N, 0);
}
long long F_Inv[MAXN];
long long F[MAXN];
long long C[MAXN], G[MAXN], G_Inv[MAXN];
int main()
{
    int n = read();
    F[0] = 1;
    for (int i = 1; i <= n; i++)
        F[i] = F[i - 1] * i % MOD;
    F_Inv[n] = pow_mod(F[n], MOD - 2);
    for (int i = n - 1; i >= 0; i--) F_Inv[i] = F_Inv[i + 1] * (i + 1) % MOD;
    for (int i = 0; i <= n; i++)
        G[i] = (i < 2) ? (1) : pow_mod(2, 1ll * i * (i - 1) / 2 % (MOD - 1)) * F_Inv[i] % MOD;
    for (int i = 0; i <= n; i++) C[i] = i * G[i] % MOD;
    Get_Inv(n + 1, G, G_Inv);
    N = 1;
    while (N <= n << 1)
        N <<= 1;
    Inv = pow_mod(N, MOD - 2);
    for (int i = 1; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    FFt(G_Inv, 1), FFt(C, 1);
    for (int i = 0; i < N; i++) C[i] = C[i] * G_Inv[i] % MOD;
    FFt(C, -1);
    printf ("%d\n", C[n] * F[n - 1] % MOD);
    // while (1);
}

BZOJ3771: Triple

Mon, 26 Feb 2018 07:32:23 GMT

Description

我们讲一个悲伤的故事。从前有一个贫穷的樵夫在河边砍柴。这时候河里出现了一个水神，夺过了他的斧头，说： “这把斧头，是不是你的？” 樵夫一看：“是啊是啊！” 水神把斧头扔在一边，又拿起一个东西问： “这把斧头，是不是你的？” 樵夫看不清楚，但又怕真的是自己的斧头，只好又答：“是啊是啊！” 水神又把手上的东西扔在一边，拿起第三个东西问： “这把斧头，是不是你的？” 樵夫还是看不清楚，但是他觉得再这样下去他就没法砍柴了。于是他又一次答：“是啊是啊！真的是！” 水神看着他，哈哈大笑道： “你看看你现在的样子，真是丑陋！” 之后就消失了。樵夫觉得很坑爹，他今天不仅没有砍到柴，还丢了一把斧头给那个水神。于是他准备回家换一把斧头。回家之后他才发现真正坑爹的事情才刚开始。水神拿着的的确是他的斧头。但是不一定是他拿出去的那把，还有可能是水神不知道怎么偷偷从他家里拿走的。换句话说，水神可能拿走了他的一把，两把或者三把斧头。樵夫觉得今天真是倒霉透了，但不管怎么样日子还得过。他想统计他的损失。樵夫的每一把斧头都有一个价值，不同斧头的价值不同。总损失就是丢掉的斧头价值和。他想对于每个可能的总损失，计算有几种可能的方案。注意：如果水神拿走了两把斧头a和b，(a,b)和(b,a)视为一种方案。拿走三把斧头时，(a,b,c),(b,c,a),(c,a,b),(c,b,a),(b,a,c),(a,c,b)视为一种方案。

Input

第一行是整数N，表示有N把斧头。接下来n行升序输入N个数字Ai，表示每把斧头的价值。

Output

若干行，按升序对于所有可能的总损失输出一行x y，x为损失值，y为方案数。

Sample Input

Sample Output

样例解释

11 有两种方案是4+7和5+6，其他损失值都有唯一方案，例如4=4,5=5,10=4+6,18=5+6+7.

HINT

所有数据满足：Ai<=40000

题解

一把，两把或者三把

首先写出生成函数$F(x) = x^{a_1}+x^{a_2}+x^{a_3}+...+x^{a_n}$
两把就是$F^2(x)$减去$B(x)=x^{2a_1}+x^{2a_2}+x^{2a_3}+...+x^{2a_n}$
三把就是$F^3(x)$减去$3*F(x)*B(x)$加上$C(x)=x^{3a_1}+x^{3a_2}+x^{3a_3}+...+x^{3a_n}$ FFT优化乘法

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const double pi = acos(-1.);
struct Complex
{
    double x, y;
    Complex() { x = y = 0; }
    Complex(double a, double b) : x(a), y(b) {}
    Complex operator+(const Complex &a) { return Complex(x + a.x, y + a.y); }
    Complex operator-(const Complex &a) { return Complex(x - a.x, y - a.y); }
    Complex operator*(const Complex &a) { return Complex(x * a.x - y * a.y, x * a.y + y * a.x); }
    Complex operator*(const double a) { return Complex(x * a, y * a); }
    Complex Get() { return Complex(x, -y); }
};
double Inv;
const int MAXN = 5e5 + 5;
int N;
int rev[MAXN];
void FFt(Complex *a, int op)
{
    Complex wn, w, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = Complex(cos(pi / (k >> 1)), op * sin(pi / (k >> 1)));
        for (int j = 0; j < N; j += k)
        {
            w = Complex(1, 0);
            for (int i = 0; i < (k >> 1); i++, w = w * wn)
            {
                t = a[i + j + (k >> 1)] * w;
                a[i + j + (k >> 1)] = a[i + j] - t;
                a[i + j] = a[i + j] + t;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = a[i] * Inv;
}
Complex A[MAXN], B[MAXN], C[MAXN];
Complex tmp[MAXN];
long long ans[MAXN];
int m = 0;
int main()
{
    int n = read();
    for (int i = 1; i <= n; i++)
    {
        int x = read();
        ans[x]++;
        A[x].x = 1;
        B[2 * x].x = 1;
        C[3 * x].x = 1;
        m = max(m, 3 * x);
    }
    m = m + m + 1;
    N = 1;
    while (N < m) 
        N <<= 1;
    for (int i = 1; i < N; i++) 
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    Inv = 1. / N;
    FFt(A, 1);
    for (int i = 0; i < N; i++) tmp[i] = A[i] * A[i];
    FFt(tmp, -1);
    for (int i = 0; i < N; i++) ans[i] += round((tmp[i].x - B[i].x) / 2);
    // for (int i = 0; i < N; i++)
    //     if (ans[i])
    //         printf ("%d %lld\n", i, ans[i]);
    // printf ("======================================\n");
    FFt(B, 1);
    for (int i = 0; i < N; i++) B[i] = B[i] * A[i];
    FFt(B, -1);
    for (int i = 0; i < N; i++) tmp[i] = A[i] * A[i] * A[i];
    FFt(tmp, -1);
    for (int i = 0; i < N; i++) ans[i] += round((tmp[i].x - B[i].x * 3 + C[i].x * 2) / 6);
    for (int i = 0; i <= m / 2; i++)
        if (ans[i])
            printf ("%d %lld\n", i, ans[i]);
    // while (1);
}

BZOJ3509: [CodeChef] COUNTARI

Mon, 26 Feb 2018 06:28:02 GMT

Description

给定一个长度为N的数组A[]，求有多少对i, j, k（1<=i<j<k<=N）满足A[k]-A[j]=A[j]-A[i]。

Input

第一行一个整数N（N<=10^5）。接下来一行N个数A[i]（A[i]<=30000）。

Output

一行一个整数。

Sample Input

10
3 5 3 6 3 4 10 4 5 2

Sample Output

分块FFT
先分块，暴力求出有三个在同一块，和两个在同一块的答案
三个都不在一块的FFT

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 1e6;
const int MOD = 998244353;
long long pow_mod(long long a, long long b, long long P)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1) ans = ans * a % P;
        b >>= 1;
        a = a * a % P;
    }
    return ans;
}
long long Inv, N;
int rev[MAXN];
void FFt(long long *a, int op)
{
    long long wn, w, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = pow_mod(3, op == 1 ? (MOD - 1) / k : MOD - 1 - (MOD - 1) / k, MOD);
        for (int j = 0; j < N; j += k)
        {
            w = 1;
            for (int i = 0; i < (k >> 1); i++, w = w * wn % MOD)
            {
                t = a[i + j + (k >> 1)] * w % MOD;
                a[i + j + (k >> 1)] = (a[i + j] - t + MOD) % MOD;
                a[i + j] = (a[i + j] + t) % MOD;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = a[i] * Inv % MOD;
}
int Sum1[MAXN], Sum2[MAXN];
int W[MAXN];
int l[MAXN], r[MAXN];
long long A[65537], B[65537];
int main()
{
    int n = read();
    for (int i = 0; i < n; i++)
        W[i] = read();
    int len = min((int)sqrt(n) * 6, n);
    int num = n / len;
    if (n % len) num++;
    long long ans = 0;
    for (int i = 1; i <= num; i++)
    {
        l[i] = (i - 1) * len;
        r[i] = min(l[i] + len - 1, n - 1);
    }
    for (int i = 1; i <= num; i++)
    {
        for (int j = l[i]; j <= r[i]; j++)
        {
            for (int k = j + 1; k <= r[i]; k++) 
                if (2 * W[j] - W[k] >= 0)
                    ans += Sum1[2 * W[j] - W[k]];
            Sum1[W[j]]++;
        }
    }
    for (int i = num; i >= 1; i--)
    {
        for (int j = l[i]; j <= r[i]; j++)
        {
            for (int k = j + 1; k <= r[i]; k++)
                if (2 * W[k] - W[j] >= 0)
                    ans += Sum2[2 * W[k] - W[j]];
        }
        for (int j = l[i]; j <= r[i]; j++)
            Sum2[W[j]]++;
    }
    N = 65536;
    Inv = pow_mod(N, MOD - 2, MOD);
    for (int i = 1; i < N; i++)
        if (i & 1) 
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    for (int i = 2; i < num; i++)
    {
        memset (A, 0, sizeof (A));
        memset (B, 0, sizeof (B));
        for (int j = 0; j < l[i]; j++) A[W[j]]++;
        for (int j = r[i] + 1; j < n; j++) B[W[j]]++;
        FFt(A, 1), FFt(B, 1);
        for (int j = 0; j < N; j++) A[j] = A[j] * B[j];
        FFt(A, -1);
        for (int j = l[i]; j <= r[i]; j++) ans += A[2 * W[j]];
    }
    printf ("%lld\n", ans);
}

BZOJ3527: [ZJOI2014] 力

Sun, 25 Feb 2018 21:16:40 GMT

Description

给出n个数qi，给出Fj的定义如下：
令Ei=Fi/qi，求Ei.

Input

第一行一个整数n。
接下来n行每行输入一个数，第i行表示qi。
n≤100000，0<qi<1000000000

Output

n行，第i行输出Ei。与标准答案误差不超过1e-2即可。

Sample Input

5
4006373.885184
15375036.435759
1717456.469144
8514941.004912
1410681.345880

Sample Output

-16838672.693
3439.793
7509018.566
4595686.886
10903040.872

题解

写写题解证明自己还活着

这道题是一道比较基础的题目

先把Ei写出来得

$$ E_i = \sum_{i<j} {\frac{p_i}{(i - j) ^ 2}} - \sum_{i>j}{\frac{qi}{(i - j)^2}}$$

令 $f(i) = q_i,\ g(i) = \frac{1}{i^2}$

$$E_j=\sum_{i=1}^{j-1}f(i) \times g(j-i)-\sum_{i=j+1}^nf(i) \times g(j-i)$$

前一部分直接FFT算。

后一部分$\sum_{i=j+1}^nf(i) \times g(j-i)=\sum_{i=1}^{n-j}f(i+j) \times g(i)$

令 $f'(n-i-j)=f(i+j)$ ，则第二部分变为 $\sum_{i=0}^{n-j-1}f'(n-i-j-1) \times g(i)$，转化为卷积的形式用FFT解即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <complex>
using namespace std;
#define Complex complex<double>
const double pi = acos(-1.);
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 100005 * 8;
int rev[MAXN]; 
double Inv;
int N;
void FFt(Complex *a, int op)
{
    Complex t, w;
    for (int i = 0; i < N; i++)
        if (i > rev[i]) swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        Complex wn(cos(pi / (k >> 1)), op * sin(pi / (k >> 1)));
        for (int j = 0; j < N; j += k)
        {
            w = Complex(1, 0);
            for (int i = 0; i < (k >> 1); i++, w = w * wn)
            {
                t = a[i + j + (k >> 1)] * w;
                a[i + j + (k >> 1)] = a[i + j] - t;
                a[i + j] = a[i + j] + t;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] *= Inv;
}
Complex a[MAXN], b[MAXN], g[MAXN];
int main()
{
    int n = read();
    n--;
    for (int i = 0; i <= n; i++)
    {
        double x;
        scanf ("%lf", &x);
        b[n - i] = a[i] = x;
    }
    for (int i = 1; i <= n; i++) g[i] = (1. / i / i);
    int m = n + n + 1;
    N = 1;
    while (N < m)
        N <<= 1;
    Inv = 1. / N;
    for (int i = 0; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    FFt(a, 1), FFt(b, 1), FFt(g, 1);
    for (int i = 0; i < N; i++) a[i] = a[i] * g[i];
    for (int i = 0; i < N; i++) b[i] = b[i] * g[i];
    FFt(a, -1), FFt(b, -1);
    for (int i = 0; i <= n; i++)
        printf ("%.3f\n", a[i].real() - b[n - i].real());
    // while (1);
}

BZOJ2688: Green Hackenbush

Thu, 18 Jan 2018 20:57:55 GMT

Description

有一个古老的游戏叫做Green Hackenbush，游戏是这样进行的：两个人轮流在一棵树上删边，每次删边后不与根联通的子树直接被ignore，不能删边的游戏者输。Alice和Bob也在玩这个游戏，不过他们面对的是n棵树，第i棵树是含有a[i]个节点的二叉树。先手的Alice想知道自己有多大的概率获胜(假设我们的Alice和Bob同学都是无限聪明的)。

Input

第一行一个数n。接下来每行一个数a[i]。

Output

一个保留6位小数的实数ans。

Sample Input

1
2

Sample Output

1.000000

HINT

对于100%的数据，n<=100，a[i]<=100

题解

首先我们考虑正常的Green Hackenbush游戏

Step1:

让我们先从最简单的开始
假设树退化为一条链
那么我们会发现这好像就是一个Nim游戏
那么我们可以通过异或来解决这个问题

Step2:

再让我们考虑一颗树
那么根据Colon Principle原理
一个点的SG函数值为它的所有的子树的SG+1的异或和
举个例子从网上找的一张图

大家可以自己算一下

感性证明

首先不考虑这个点以下的部分(我们一会再去管他) ，在这个点以上的部分先不考虑链接这个点的那些边。
那么他上面可以看做是几个子游戏。我们可以递归的计算他们是SG值
把他们等效成一条链，然后加上链接这个点的那些边，及SG+1
根据Nim 的结论，我们可以将他们异或起来。

现在让我们考虑下面的部分
假设一个任意固定的图G，一个任意节点x，让H1和H2为任意的树，且拥有相同的SG值。考虑这样两个图G1=Gx:H1和G2=Gx:H2，Gx：Hi表示该图是把树Hi连接图的x节点。
则我们需要证明G1与G2的SG值相等
G1、G2拥有相同的SG值意味着两个游戏的总SG值为0，G1+G2的和是一个P局面，也就是必败
先手一旦在其中一幅图中取走任意一条边，后手即可在另一幅图中取走相对应的一条边。轮流下去，最后肯定是后手获胜。

然后我们搞定了正常的Green Hackenbush游戏

现在让我们来看这道题
对应$x$个点去建一颗二叉树有多少种方法?
分别考虑左右子树
我们有
$$h[x] = \sum_{i = 0}^{n - 1}{h[i] * h[n - i - 1]}$$
这好像就是卡特兰数。
然后我们设$g[i][j]$为有$i$个点的树SG值为$j$的概率

得DP方程为

$$g[n][(x + 1) ^ (y + 1)] = \sum_{i = 0}^{n - 1}{ h[i] * g[i][x] * h[n - 1 - i] * g[n - 1 - i][y]}$$

f[i][j]表示的是前i颗子树异或值为j的概率

$$f[i][j ^ k]=f[i-1][j] * g[a[i]][k]$$

搞定 $ans = 1-f[n][0]$

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int a[105];
double h[150];
double g[350][350], f[350][350];
int main()
{
    int n = read(), m = 0;
    for (int i = 1; i <= n; i++)
        a[i] = read(), m = max(m, a[i]);
    h[0] = 1;
    for (int i = 1; i <= m; i++)
        h[i] = h[i - 1] * (4 * i - 2) / (i + 1);
    g[1][0] = 1;
    for (int i = 2; i <= m; i++)
    {
        for (int j = 0; j <= 127; j++) g[i][j + 1] += h[i - 1] * 2 * g[i - 1][j];
        for (int j = 1; j < i - 1; j++)
        {
            int k = i - j - 1;
            for (int x = 0; x <= 127; x++)
                for (int y = 0; y <= 127; y++)
                    g[i][(x + 1) ^ (y + 1)] += h[j] * g[j][x] * h[k] * g[k][y];
        }
        for (int j = 0; j <= n - 1; j++) g[i][j] /= h[i];
    }
    for (int i = 0; i <= 127; i++) f[1][i] = g[a[1]][i];
    for (int i = 2; i <= n; i++)
        for (int j = 0; j <= 127; j++)
            for (int k = 0; k <= 127; k++)
                f[i][j ^ k] += f[i - 1][j] * g[a[i]][k];
    printf ("%.6f\n", 1.0 - f[n][0]);
}

BZOJ2017 [Usaco2009 Nov] 硬币游戏

Thu, 18 Jan 2018 20:44:36 GMT

Description

农夫约翰的奶牛喜欢玩硬币游戏，因此他发明了一种称为“Xoinc”的两人硬币游戏。初始时，一个有N(5 <= N <= 2,000)枚硬币的堆栈放在地上，从堆顶数起的第I枚硬币的币值为$C_i$ (1 <= $C_i$ <= 100,000)。开始玩游戏时，第一个玩家可以从堆顶拿走一枚或两枚硬币。如果第一个玩家只拿走堆顶的一枚硬币，那么第二个玩家可以拿走随后的一枚或两枚硬币。如果第一个玩家拿走两枚硬币，则第二个玩家可以拿走1，2，3，或4枚硬币。在每一轮中，当前的玩家至少拿走一枚硬币，至多拿走对手上一次所拿硬币数量的两倍。当没有硬币可拿时，游戏结束。两个玩家都希望拿到最多钱数的硬币。请问，当游戏结束时，第一个玩家最多能拿多少钱呢？

Input

第1行：1个整数N

第2..N+1行：第i+1行包含1个整数$C_i$

Output

第1行：1个整数表示第1个玩家能拿走的最大钱数。

Sample Input

Sample Output

HINT

样例说明：第1个玩家先取走第1枚，第2个玩家取第2枚；第1个取走第3，4两枚，第2个玩家取走最后1枚。

题解

设f[i][j]为还剩i个硬币这一次最多能取j个的最大价值
a[i]为硬币价值的后缀和
为了方便逆序读入
然后$f[i][j] = max(f[i][j - 1], a[i] - f[i - j][min(i - j, 2 * j)])$
搞定

#include <cstdio>
#include <algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int a[2005];
int f[2005][2005];
int main()
{
    int n = read();
    for (int i = n; i >= 1; i--) a[i] = read();
    for (int i = 1; i <= n; i++) a[i] += a[i - 1];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            f[i][j] = max(f[i][j - 1], a[i] - f[i - j][min(i - j, j * 2)]);
    printf ("%d\n", f[n][2]);
}

BZOJ1095 [ZJOI2007] Hide 捉迷藏

Tue, 16 Jan 2018 08:24:12 GMT

Description

捉迷藏 Jiajia和Wind是一对恩爱的夫妻，并且他们有很多孩子。某天，Jiajia、Wind和孩子们决定在家里玩捉迷藏游戏。他们的家很大且构造很奇特，由N个屋子和N-1条双向走廊组成，这N-1条走廊的分布使得任意两个屋子都互相可达。游戏是这样进行的，孩子们负责躲藏，Jiajia负责找，而Wind负责操纵这N个屋子的灯。在起初的时候，所有的灯都没有被打开。每一次，孩子们只会躲藏在没有开灯的房间中，但是为了增加刺激性，孩子们会要求打开某个房间的电灯或者关闭某个房间的电灯。为了评估某一次游戏的复杂性，Jiajia希望知道可能的最远的两个孩子的距离（即最远的两个关灯房间的距离）。我们将以如下形式定义每一种操作： C(hange) i 改变第i个房间的照明状态，若原来打开，则关闭；若原来关闭，则打开。 G(ame) 开始一次游戏，查询最远的两个关灯房间的距离。

Input

第一行包含一个整数N，表示房间的个数，房间将被编号为1,2,3…N的整数。接下来N-1行每行两个整数a, b，表示房间a与房间b之间有一条走廊相连。接下来一行包含一个整数Q，表示操作次数。接着Q行，每行一个操作，如上文所示。

Output

对于每一个操作Game，输出一个非负整数到hide.out，表示最远的两个关灯房间的距离。若只有一个房间是关着灯的，输出0；若所有房间的灯都开着，输出-1。

Sample Input

Sample Output

HINT

对于100%的数据， N ≤100000, M ≤500000。

动态点分治
将每次点分治中的重心建树
在每个点维护值
本题维护两个堆
C[i] 维护子树中的黑点到起分治父亲的Dis
B[i] 维护子树中C[i]的堆顶

ans 维护答案

#pragma GCC optimize("O3")
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <iostream>
#include<ext/pb_ds/priority_queue.hpp>
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='0')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN = 100005;
struct Priority_queue
{
    __gnu_pbds::priority_queue<int, less<int>, __gnu_pbds::binary_heap_tag> Q1, Q2;
    inline int size()
    {
        return Q1.size() - Q2.size();
    }
    inline void push(const int &x)
    {
        Q1.push(x);
    }
    inline void erase(const int &x)
    {
        Q2.push(x);
    }
    inline int top()
    {
        while (!Q2.empty() && Q1.top() == Q2.top())
        {
            Q1.pop();
            Q2.pop();
        }
        if (!Q1.empty()) return Q1.top();
        else return 0;
    }
    inline int top2()
    {
        if (size() < 2) return 0;
        while (!Q2.empty() && Q1.top() == Q2.top())
        {
            Q1.pop();
            Q2.pop();
        }
        int tmp = Q1.top(); Q1.pop();
        while (!Q2.empty() && Q1.top() == Q2.top())
        {
            Q1.pop();
            Q2.pop();
        }
        int ans = Q1.top(); Q1.push(tmp);
        return ans;
    }
}B[MAXN], C[MAXN], ans;
struct edge
{
    int END, next;
}v[MAXN << 1];
int first[MAXN], p;
inline void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int f[MAXN][18];
int dep[MAXN];
inline void PreDFS(int rt, int fa)
{
    dep[rt] = dep[fa] + 1;
    f[rt][0] = fa;
    for (int i = 1; i <= 17; i++) f[rt][i] = f[f[rt][i - 1]][i - 1];
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (v[i].END == fa) continue;
        PreDFS(v[i].END, rt);
    }
}
int sum, Max[MAXN], size[MAXN], root;
bool vis[MAXN];
static inline void GetRoot(int rt, int fa)
{
    size[rt] = 1; Max[rt] = 0;
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (vis[v[i].END] || v[i].END == fa) continue;
        GetRoot(v[i].END, rt);
        size[rt] += size[v[i].END];
        Max[rt] = max(Max[rt], size[v[i].END]);
    }
    Max[rt] = max(Max[rt], sum - size[rt]);
    if (Max[rt] < Max[root]) root = rt;
}
int Fa[MAXN];
static inline void Divide(int rt, int fa)
{
    vis[rt] = 1;
    Fa[rt] = fa;
    // cerr << rt << endl;
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (vis[v[i].END]) continue;
        sum = size[v[i].END], root = 0;
        GetRoot(v[i].END, 0);
        Divide(root, rt);
    }
}
static inline int LCA(int a, int b)
{
    if (dep[a] < dep[b]) swap(a, b);
    int d = dep[a] - dep[b];
    for (int i = 17; i >= 0; i--)
        if (d & (1 << i))
            d -= (1 << i), a = f[a][i];
    if (a == b) return a;
    for (int i = 17; i >= 0; i--)
        if (f[a][i] != f[b][i])
            a = f[a][i], b = f[b][i];
    return f[a][0];
}
static inline int dis(const int &a, const int &b)
{
    return dep[a] + dep[b] - 2 * dep[LCA(a, b)];
}
int Color[MAXN];
static inline void Change_To_Black(const int &Height_root, const int &Child)
{
    if (Height_root == Child)
    {
        B[Height_root].push(0);
        if (B[Height_root].size() == 2)
            ans.push(B[Height_root].top());
    }
    if (!Fa[Height_root]) return;
    int Father = Fa[Height_root];
    int Dis = dis(Father, Child);
    int tmp = C[Height_root].top();
    C[Height_root].push(Dis);
    if (Dis > tmp)
    {
        int size = B[Father].size();
        int tmp2 = B[Father].top() + B[Father].top2();
        if (tmp)
            B[Father].erase(tmp);
        B[Father].push(Dis);
        int now = B[Father].top() + B[Father].top2();
        if (now > tmp2)
        {
            if (size >= 2) ans.erase(tmp2);
            if (B[Father].size() >= 2)
                ans.push(now);
        }
    }
    Change_To_Black(Father, Child);
}
static inline void Change_To_White(const int &Height_root, const int &Child)
{
    if (Height_root == Child)
    {
        if (B[Height_root].size() == 2)
            ans.erase(B[Height_root].top());
        B[Height_root].erase(0);
    }
    if (!Fa[Height_root]) return;
    int Father = Fa[Height_root];
    int Dis = dis(Father, Child);
    int tmp = C[Height_root].top();
    C[Height_root].erase(Dis);
    if (tmp == Dis)
    {
        int size = B[Father].size();
        int tmp2 = B[Father].top() + B[Father].top2();
        B[Father].erase(Dis);
        if (C[Height_root].top())
            B[Father].push(C[Height_root].top());
        int now = B[Father].top() + B[Father].top2();
        if (now < tmp2)
        {
            if (size >= 2)
                ans.erase(tmp2);
            if (B[Father].size() >= 2)
                ans.push(now);
        }
    }
    Change_To_White(Father, Child);
}
int main()
{
    memset (first, -1, sizeof (first));
    int n = read();
    for (int i = 1; i < n; i++)
    {
        int a = read(), b = read();
        add(a, b);
        add(b, a);
        // cerr << i << endl;
    }
    PreDFS(1, 0);
    
    Max[0] = sum = n;
    GetRoot(1, 0);
    
    Divide(root, 0);
    // cerr << "11!!" << endl;
    for (int i = 1; i <= n; i++)
    {
        Color[i] = 1;
        // cerr << i << endl;
        C[i].push(0);
        // Change_To_Black(i, i);
    }
    for (int i = 1; i <= n; i++)
    {
        Change_To_Black(i, i);
        // cerr << i << endl;        
    }
    // for (int i = 1; i <= n; i++) cerr << "i fa is " << Fa[i] << endl;
    int m = read();
    char s[10];
    for (int i = 1; i <= m; i++)
    {
        // cerr << i << endl;
        scanf ("%s", s);
        if (s[0] == 'C')
        {
            int k = read();
            if (Color[k])
            {
                Color[k] = 0;
                Change_To_White(k, k);
            }
            else
            {
                Color[k] = 1;
                Change_To_Black(k, k);
            }
        }
        else
            printf ("%d\n", ans.top());
    }
}

上下界网络流笔记

Tue, 16 Jan 2018 07:19:34 GMT

无源汇可行流

将上下界的网络流转化为普通网络流。

建图:

添加源点 $S$ 与汇点 $T$
对于原图中的边 $a \to b$ 流量限制为$[c, d]$, 则连边 $a \to b$, 流量为 $d-c$
对于原图中的每一个点 $i$ , 记 $d(i)$ 为流入这个点的所有边的下界 $-$ 流出这个点的所有边的下界
- 若$d(i) > 0$连 $S \to i$, 流量为 $d(i)$
- 若$d(i) < 0$连 $i \to T$, 流量为 $-d(i)$

在新图上跑 $S \to T$ 的最大流
若新图满流则原图存在可行流
原图中边流量为新图中对应边的流量加下界。

有源汇可行流

建图:

在原图中加一条 $t \to s$ 的边流量为 $[0, INF]$
用无源汇求解

有源汇最大流

建图同上

在新图上跑 $S \to T$ 最大流记此时 $\sum{f(s, i)} = sum1$
讲 $t \to s$ 的边拆掉，跑 $s \to t$ 的最大流
记此时 $\sum{f(s, i)} = sum2$
则答案为 $sum1+sum2$

有源汇最小流

建图方法同无源汇可行流
求 $S \to T$ 最大流
连边 $t \to s,INF$
求 $S \to T$ 最大流
答案为 $t \to s$ 的实际流量

有源汇费用流

将上下界的网络流转化为普通网络流。

建图:

添加源点 $S$ 与汇点 $T$
对于原图中的边 $a \to b$ 流量限制为 $[c, d]$, 费用为 $v$ , 则连边 $a \to b$ , 流量为 $d-c$ , 费用为 $v$
对于原图中的每一个点 $i$, 记 $d(i)$ 为流入这个点的所有边的下界 $-$ 流出这个点的所有边的下界
- 若$d(i) > 0$连 $S \to i$, 流量为 $d(i)$, 费用为 $0$
- 若$d(i) < 0$连 $i \to T$, 流量为 $-d(i)$, 费用为 $0$

连边 $t \to s$，流量为 $INF$，费用为 $0$

跑 $S \to T$ 的最小费用最大流
答案为 $ans+$原图中边的下界$\times$边的费用

BZOJ2716 [Violet 3]天使玩偶

Thu, 14 Dec 2017 14:16:10 GMT

Description

Input

Output

Sample Input & Output

HINT

题解

KD-Tree带插入的板子。
应该rebuild的。
但没rebuild就过了。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int INF = 0x3f3f3f3f;
const double alpha = 0.756;
const int MAXN = 5e5 + 5;

int now;

struct Point
{
    int d[2];
    int &operator[](const int &x)
    {
        return d[x];
    }
    inline bool operator < (const Point &x) const 
    {
        return d[now] == x.d[now] ? d[now ^ 1] < x.d[now ^ 1] : d[now] < x.d[now];
    }
}a[MAXN], cur;

#define dis(_, __) (\
    int(abs(_[0] - __[0]) + abs(_[1] - __[1]))\
)

#define size(_) ((_) ? (_)->s : 0)

struct Node
{
    Node *ch[2];
    Point v;
    int s, d;
    int Max[2], Min[2];
    Node(Point x)
    {
        ch[0] = ch[1] = NULL;
        v = x;
        s = 1, d = now;
        Max[0] = Min[0] = x[0];
        Max[1] = Min[1] = x[1];
    }
    Node(){;}
    inline bool operator < (const Node &x) const 
    {
        return v < x.v;
    }
    bool IsBad()
    {
        return ((size(ch[0]) > s * alpha) || (size(ch[1]) > s * alpha));
    }
    void Pushup(Node *x)
    {
        if (!x) return;
        for (int i = 0; i <= 1; i++) Min[i] = min(Min[i], x->Min[i]);
        for (int i = 0; i <= 1; i++) Max[i] = max(Max[i], x->Max[i]);
        s += x->s;
    }
    int min_dis()
    {
        int ans = 0;
        ans += max(Min[0] - cur[0], 0) + max(cur[0] - Max[0], 0);
        ans += max(Min[1] - cur[1], 0) + max(cur[1] - Max[1], 0);
        return ans;
    }
}*root;

inline void Build(Node *&rt, int l, int r, int d = 0)
{
    if (l > r) return;
    int mid = l + r >> 1;
    now = d;
    nth_element(a + l, a + mid, a + r + 1);
    rt = new Node(a[mid]);
    Build(rt->ch[0], l, mid - 1, d ^ 1);
    Build(rt->ch[1], mid + 1, r, d ^ 1);
    rt->s = 1;
    rt->Pushup(rt->ch[0]);
    rt->Pushup(rt->ch[1]);
}

Node **res;

inline void Insert(Node *&rt)
{
    if (rt == NULL)
    {
        rt = new Node(cur);
        res = NULL;
        return;
    }
    now = rt->d;
    if (cur < rt->v) Insert(rt->ch[0]);
    else Insert(rt->ch[1]);
    rt->s = 1;
    rt->Pushup(rt->ch[0]);
    rt->Pushup(rt->ch[1]);
    if (rt->IsBad()) res = &rt;
}


inline void Insert(Point x)
{
    cur = x;
    Insert(root);
}

int Min_ans;

inline void Query(Node *rt)
{
    if (!rt) return;
    // if (rt->min_dis() > Min_ans) return;
    Min_ans = min(Min_ans, dis(rt->v, cur));
    int dis_l = rt->ch[0] ? rt->ch[0]->min_dis() : INF;
    int dis_r = rt->ch[1] ? rt->ch[1]->min_dis() : INF;
    if (dis_l < dis_r)
    {
        Query(rt->ch[0]);
        if (dis_r < Min_ans) Query(rt->ch[1]);
    }
    else
    {
        Query(rt->ch[1]);
        if (dis_l < Min_ans) Query(rt->ch[0]);
    }
}

inline int Query(Point x)
{
    cur = x;
    Min_ans = INF;
    Query(root);
    return Min_ans;
}

int main()
{
    // freopen("1.in", "r", stdin);
    // freopen("2.out", "w", stdout);
    int n, m;
    n = read(), m = read();
    for (int i = 1; i <= n; i++)
        a[i][0] = read(), a[i][1] = read();
    Build(root, 1, n);
    Point x;
    while (m--)
    {
        int t = read();
        if (t == 1)
        {
            x[0] = read(), x[1] = read();
            Insert(x);
        }
        else
        {
            x[0] = read(), x[1] = read();
            printf ("%d\n", Query(x));
        }
    }
}

NOIP 考前，考中，考后

Sat, 11 Nov 2017 08:14:15 GMT

2017-11-9

明天就出发了，还有不少东西没有复习，心里好虚啊。
觉得自己什么都不会，不知道怎么办。
很压抑啊，题也做不下去了，下午去吃了个火锅。放松了些。
但回到机房又是一种压抑的感觉。
好难受。
果然是还没有做好退役的准备啊。

唉...

2017-11-13

考完了，也是回到了学校。
先是一个假期，然而我好象并不能回家。
在机房待着。
反正也是考完了，考的怎样就不想管了。
不管能不能参加省选，首先迎接我们的是恐怖的文化课补课。
以及那让人讨厌的会考。。

BZOJ3925 状压DP+概率DP

Mon, 30 Oct 2017 08:14:15 GMT

转载自 Cooook BZOJ3925 状压DP+概率DP 转载请注明原文地址

Description

傲娇少女幽香是一个很萌很萌的妹子，而且她非常非常地有爱心，很喜欢为幻想乡的人们做一些自己力所能及的事情来帮助他们。这不，幻想乡突然发生了地震，所有的道路都崩塌了。现在的首要任务是尽快让幻想乡的交通体系重新建立起来。幻想乡一共有n个地方，那么最快的方法当然是修复n-1条道路将这n个地方都连接起来。幻想乡这n个地方本来是连通的，一共有m条边。现在这m条边由于地震的关系，全部都毁坏掉了。每条边都有一个修复它需要花费的时间，第i条边所需要的时间为ei。地震发生以后，由于幽香是一位人生经验丰富，见得多了的长者，她根据以前的经验，知道每次地震以后，每个ei会是一个0到1之间均匀分布的随机实数。并且所有ei都是完全独立的。现在幽香要出发去帮忙修复道路了，她可以使用一个神奇的大魔法，能够选择需要的那n-1条边，同时开始修复，那么修复完成的时间就是这n-1条边的ei的最大值。当然幽香会先使用一个更加神奇的大魔法来观察出每条边ei的值，然后再选择完成时间最小的方案。幽香在走之前，她想知道修复完成的时间的期望是多少呢？

Input

第一行两个数n,m，表示地方的数量和边的数量。其中点从1到n标号。接下来m行，每行两个数a,b，表示点a和点b之间原来有一条边。这个图不会有重边和自环。

Output

一行输出答案，四舍五入保留6位小数。

Sample Input

Sample Output

0.800000

HINT

对于n个[0,1]之间的随机变量x1,x2,...,xn，第k小的那个的期望值是k/(n+1)。

题解前的扯淡

贼NB的一道题,有两种做法,PoPoQQQ大爷的积分没看懂...于是写了概率DP
WQ刚了一天没刚出来,ZZH还在刚...
听WQ说dg说这种题刚不出来就弃了吧233333

题解

题目让求的是最小生成树最大边的期望
我们设最小生成树的最大边的排名为$i$
设$F(i)$ 为最小生成树最大边排名为$i$的贡献
由提示可知$F(i) = \frac{i}{m+1}$
设$P(i)$为最小生成树最大边排名为$i$的概率
则$Ans=\sum_{i=1}^{m}{\frac{i*P(i)}{m+1}}$
然后就可以惊喜的发现这个$P(i)$并不好求
考虑转化
设$T(i)$为最小生成树最大边排名大于等于$i$的概率
那么$Ans=\frac{\sum_{i=1}^{m}{T(i)}}{m+1}$
至于为什么
首先根据定义$T(i)=\sum_{j=i}^{m}{P(j)}$
那么每个$P(i)$被累加的次数正好是$i$次
所以成立
但$T(i)$还是不好求
而最小生成树最大边的排名为$i$则说明排名小于$i$的边不能使图联通
设$M(i)$为排名小于i的边不能使图联通的概率
所以$T(i)=M(i)$ 所以求$\frac{\sum_{i=0}^{m}{M(i)}}{m+1}$就是答案了
然后怎么还是不好求...
不联通的不好求,联通的还不好求么
终于进入$DP$的环节了....
由于$n$的范围很小,所以我们考虑状态压缩
设$f_{i,j}$为点集为$i$有j条边且点之间不联通的方案数
设$g_{i,j}$为点集为$i$有j条边且点之间联通的方案数
设$cnt_i$为点集为$i$的边的数量
从$cnt_i$条边里选$j$条边的方案数为$C_{cnt_i}^{j}$
而选出来$j$条边后这个点集只有联通和不联通两种状态
所以$f_{i,j}+g_{i,j}=C_{cnt_i}^{j}$
方程的转移可以通过选取这个联通块内的一个点,然后枚举那些点和这个点联通来转移
即为$f_{i,j}+=g_{S,k}*C_{cnt_{i-S}}^{j-k}$
然后根据$f_{i,j}+g_{i,j}=C_{cnt_i}^{j}$来转移$g$
最后统计答案的时候$\frac{\sum_{i=0}^{m}{\frac{f_{ALL,i}}{C_m^i}}}{m+1}$
终于完了QWQ....

#include <stdio.h>
#include <iostream>
#define int long long 
#define fi first
#define se second
#define lowbit(_) ((_)&(-_))
typedef std::pair<int,int> pii;
int f[1<<10][50],g[1<<10][50],n,m,full,cnt[1<<10],C[50][50];
pii a[50];


char xb[1<<15],*xs,*xt;
#define getc() (xs == xt && (xt = (xs = xb) + fread(xb,1,1<<15,stdin),xs == xt)?0:*xs++)
inline int read() {
    int x = 0, f = 1;
    char ch = getc();
    for (; ch < '0' || ch > '9'; ch = getc()) if (ch == '-') f = -f;
    for (; ch >= '0' && ch <= '9'; ch = getc()) x = x * 10 + (ch ^ 48);
    return x * f;
}

void Pre_Work() {
    for (int i = 0; i <= 45; i++) {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++) C[i][j] = C[i-1][j] + C[i-1][j-1];
    }
}

inline int Cnt_Bit(int S) {
    int cnt = 0;
    for (; S; S -= lowbit(S)) cnt ++;
    return cnt;
}

signed main() {
    Pre_Work();
    n = read(); m = read(); full = (1 << n) - 1;
    for (int i = 1; i <= m; i++) a[i].fi = read(),a[i].se = read();
    for (int i = 1; i <= full; i++) 
        for (int j = 1; j <= m; j++)
            if (((1<<a[j].fi-1) & i) && ((1<<a[j].se-1) & i)) cnt[i] ++;
    for (int i = 1; i <= full; i++) {
        if (Cnt_Bit(i) == 1) {
            g[i][0] = 1;
            continue;
        }
        int j = lowbit(i);
        for (int S = (i - 1) & i; S; S = (S - 1) & i)
            if (j & S) {
                for (int k = 0; k <= cnt[S]; k++)
                    for (int o = 0; o <= cnt[i ^ S]; o++)
                        f[i][o+k] += g[S][k] * C[cnt[i^S]][o];
            }
        for (int k = 0; k <= cnt[i]; k++) g[i][k] = C[cnt[i]][k] - f[i][k];
    }
    double Ans = 0.0;
    for (int i = 0; i <= m; i++) Ans += f[full][i] / 1.0 / C[cnt[full]][i];
    printf("%.6lf\n",Ans/(m+1));
    return 0;
}

Codeforces 671D Roads in Yusland

Sun, 29 Oct 2017 20:36:20 GMT

Description

Mayor of Yusland just won the lottery and decided to spent money on something good for town. For example, repair all the roads in the town.

Yusland consists of n intersections connected by n - 1 bidirectional roads. One can travel from any intersection to any other intersection using only these roads.

There is only one road repairing company in town, named "RC company". Company's center is located at the intersection 1. RC company doesn't repair roads you tell them. Instead, they have workers at some intersections, who can repair only some specific paths. The i-th worker can be paid ci coins and then he repairs all roads on a path from ui to some vi that lies on the path from ui to intersection 1.

Mayor asks you to choose the cheapest way to hire some subset of workers in order to repair all the roads in Yusland. It's allowed that some roads will be repaired more than once.

If it's impossible to repair all roads print -1.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of cities in Yusland and the number of workers respectively.

Then follow n−1 line, each of them contains two integers xi and yi (1 ≤ xi, yi ≤ n) — indices of intersections connected by the i-th road.

Last m lines provide the description of workers, each line containing three integers ui, vi and ci (1 ≤ ui, vi ≤ n, 1 ≤ ci ≤ 109). This means that the i-th worker can repair all roads on the path from vi to ui for ci coins. It's guaranteed that vi lies on the path from ui to 1. Note that vi and ui may coincide.

Output

If it's impossible to repair all roads then print -1. Otherwise print a single integer — minimum cost required to repair all roads using "RC company" workers.

input

output

题意

给一颗树，给定m对祖先节点关系。每选用一对关系需要付出c的花费，求用这些关系将所有边都覆盖的最小花费。

本题有 $nlog(n)$ 树DP做法请看CF671D 树形DP+数据结构优化DP

这里我想说一下 $nlog(n)$ 的贪心做法

我们将修路转化为修点， 1 号点不用修
首先我们设$x_i$为第$i$个工人的使用次数。那么显然$x_i \geq 0$
然设一个$A$矩阵如果第$j$个工人能覆盖到第$i$点那么$A_{i,j}=1$否则$A_{i,j}=0$
那么很显然对于$(\forall 2 <= i <= n)$都有$\sum_{j = 1}^{m}{A_{i,j}*x_j} > 0$

如果将这个过程看作矩阵乘，将x看作m行1列的矩阵
那么 $$\begin{bmatrix} A_{1,1} & A_{1,2} & A_{1,3} & \cdots & A_{1,m} \ A_{2,1} & A_{2,2} & A_{2,3} & \cdots & A_{2,m} \ \vdots & \vdots & \vdots & \ddots & \vdots \ A_{n,1} & A_{n,2} & A_{n,3} & \cdots & A_{n,m} \ \end{bmatrix} \begin{bmatrix} x_{1,1} \ x_{1,2} \ x_{1,3} \ \vdots \ x_{1,m} \ \end{bmatrix} \geq \begin{bmatrix} 1 \ 1 \ 1 \ \vdots \ 1 \ \end{bmatrix}$$

我们设右边的矩阵为$e$

那么我们要求的答案为 $$ min\{\sum_{j=1}^{m}c_j * x_j\} $$

如果将c看作矩阵则答案为 $min\{c^Tx\}$

那么我们发现他是一个线性规划问题。
我们可以考虑它的对偶问题。
由于对偶问题求得到函数值与原问题相等，那么我们只需要求出对偶问题的答案。

下面说一下对偶问题的构造

给每个原始约束条件定义一个非负对偶变量$y_i (i=1,2,…,m)$;

使原问题的目标函数系数cj变为其对偶问题约束条件的右端常数

使原问题约束条件的右端常数bi变为其对偶问题目标函数的系数；

将原问题约束条件的系数矩阵转置，得到其对偶问题约束条件的系数矩阵；

改变约束条件不等号的方向，即将"=<"改为">="；

原问题“max”型，对偶问题为“min”型．反之亦然.

那么本题的对偶问题为

$y >= 0$ $A^Ty <= c$

求$max{e^Ty}$
$e$ 是上文中设的矩阵

那么用人话说就是

每个点可以选多次一个工人的路径上的点的选择次数的和在$c_i$以内，求所有点选择次数的最大和。

我们可以贪心的由下向上选取。
用一个set启发式合并就可以了。

时间复杂度$nlog(n)$ 常数略大。

// #pragma GCC optimize("O3")
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;
const int MAXN = 300005;
char xch,xB[1<<15],*xS=xB,*xTT=xB;
#define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
struct edge
{
    int END, next;
}v[MAXN << 1];
int first[MAXN], p;
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
struct data
{
    int v, cnt;
    data(int c = 0, int cn = 0)
    {
        v = c, cnt = cn;
    }
    bool operator < (const data &a) const
    {
        return cnt == a.cnt ? v < a.v : cnt < a.cnt;
    }
};
vector<data> Add[MAXN], rm[MAXN];
set<data> st[MAXN];
long long ans;
int C[MAXN], Ad[MAXN];
bool died;
void dfs(int rt, int fa)
{
    set<data>::iterator it;
    for (int i = 0; i < Add[rt].size(); i++)
        st[rt].insert(Add[rt][i]);
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (v[i].END == fa) continue;
        dfs(v[i].END, rt);
        if (died) return;
        if (st[v[i].END].size() > st[rt].size())
            swap(st[v[i].END], st[rt]), swap(Ad[v[i].END], Ad[rt]);
        for (it = st[v[i].END].begin(); it != st[v[i].END].end(); it++)
            st[rt].insert(data(it->v, C[it->v] = it->cnt - Ad[v[i].END] + Ad[rt]));
    }
    for (int i = 0; i < rm[rt].size(); i++)
        st[rt].erase(data(rm[rt][i].v, C[rm[rt][i].v]));
    if (rt == 1) return;
    if (st[rt].empty()) {died = 1; return;}
    ans += st[rt].begin()->cnt - Ad[rt];
    Ad[rt] += st[rt].begin()->cnt - Ad[rt];
}
signed main()
{
    int n = read(), m = read(), a, b, c;
    memset (first, -1, sizeof (first));
    for (int i = 1; i < n; i++)
    {
        a = read(), b = read();
        add(a, b);
        add(b, a);
    }
    for (int i = 1; i <= m; i++)
    {
        a = read(), b = read(), c = read();
        Add[a].push_back(data(i, c));
        rm[b].push_back(data(i, c));
        C[i] = c;
    }
    dfs(1, 0);
    if (died) printf ("-1");
    else printf ("%lld", ans);
}

BZOJ 3167 [Heoi2013] Sao

Sat, 28 Oct 2017 20:20:20 GMT

题目描述

WelcometoSAO(StrangeandAbnormalOnline)。这是一个VRMMORPG，含有n个关卡。但是，挑战不同关卡的顺序是一个很大的问题。有n–1个对于挑战关卡的限制，诸如第i个关卡必须在第j个关卡前挑战，或者完成了第k个关卡才能挑战第l个关卡。并且，如果不考虑限制的方向性，那么在这n–1个限制的情况下，任何两个关卡都存在某种程度的关联性。即，我们不能把所有关卡分成两个非空且不相交的子集，使得这两个子集之间没有任何限制。

输入格式

第一行，一个整数T，表示数据组数。对于每组数据，第一行一个整数n，表示关卡数。接下来n–1行，每行为“i sign j”,其中$0≤i,j≤n–1$且$i≠j$，sign为“<”或者“>”，表示第i个关卡必须在第j个关卡前/后完成。 $T≤5, 1≤n≤1000$

输出格式

对于每个数据，输出一行一个整数，为攻克关卡的顺序方案个数，mod1,000,000,007输出。

样例输入

样例输出

题解

先做了ALO，又做了SAO。
然后就突然想看刀剑了，虽然看来好几遍了，不过河北的省选真会玩儿。
什么时候来个GGO就好了。

回到这道题:

首先将本题转化为一个树上问题（这tm的不是显然吗）。
然后我们发现答案只与每对点的遍历数序有关。
那么我们定义$f[i][j]$为一$i$为根节点的子树中有$j$个比他小。
那么假设$i$的子节点$u$要求小于$i$
那么以$u$为根的子树中有可能有$[0, k - 1]$ 个数比$u$小
那么在考虑小于他的数的合并顺序，由插板法得$C_{j}^{k}$
同理小于它的为$C_{size[i] + size[u] - j - 1}^{size[u] - k}$ 综上转移方程为
$$f[i][j + k] = f[i][j] * \sum_{c=0}^{k-1}{f[u][c]} * C_{j + k}^{j} * C_{size[u] + size[i] - k - j - 1}^{size[u] - k}$$ 大于与此类似

不知道为什么数组越界过来

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 1005;
const int MOD = 1000000007;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct edge
{
    int END, next, v;
}v[MAXN << 1];
int first[MAXN], p;
void add(int a, int b, int c)
{
    v[p].END = b;
    v[p].next = first[a];
    v[p].v = c;
    first[a] = p++;
}
long long f[MAXN][MAXN];
long long g[MAXN];
long long Sum[MAXN][MAXN];
long long C[MAXN][MAXN];
int size[MAXN];
void dfs(int rt, int fa)
{
    size[rt] = f[rt][0] = 1;
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (v[i].END == fa) continue;
        dfs(v[i].END, rt);
        for (int j = 0; j < size[rt] + size[v[i].END]; j++) g[j] = 0;
        if (v[i].v == 1)
            for (int j = 0; j < size[rt]; j++)
                for (int k = 0; k <= size[v[i].END]; k++)
                {
                    long long tmp = f[rt][j] * Sum[v[i].END][k - 1] % MOD;
                    long long rmp = C[j + k][j] * C[size[rt] + size[v[i].END] - k - j - 1][size[v[i].END] - k] % MOD;
                    (g[j + k] += tmp * rmp % MOD) %= MOD;
                }
        else
            for (int j = 0; j < size[rt]; j++)
                for (int k = 0; k <= size[v[i].END]; k++)
                {
                    long long tmp = f[rt][size[rt] - j - 1] * (Sum[v[i].END][size[v[i].END] - 1] - Sum[v[i].END][size[v[i].END] - k - 1] + MOD) % MOD;
                    long long rmp = C[j + k][j] % MOD * C[size[v[i].END] + size[rt] - k - j - 1][size[v[i].END] - k] % MOD;
                    (g[size[rt] + size[v[i].END] - j - k - 1] += tmp * rmp % MOD) %= MOD;
                }
        size[rt] += size[v[i].END];
        for (int j = 0; j < size[rt]; j++) f[rt][j] = g[j];
    }
    Sum[rt][0] = f[rt][0];
    for (int i = 1; i < size[rt]; i++)
        Sum[rt][i] = (Sum[rt][i - 1] + f[rt][i]) % MOD;
}
int main()
{
    int t = read();
    C[0][0] = 1;    
    for (int i = 1; i <= 1000; i++)
    {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++)
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
    }
    while (t--)
    {
        memset (size, 0, sizeof (size));
        memset (Sum, 0, sizeof (Sum));
        memset (f, 0, sizeof (f));
        memset (first, -1, sizeof (first));
        p = 0;
        int n = read(), a, b;
        char c[3];
        for (int i = 1; i < n; i++)
        {
            scanf ("%d%s%d", &a, c, &b);
            a++, b++;
            if (c[0] == '>') add(a, b, 1), add(b, a, -1);
            else add(a, b, -1), add(b, a, 1);
        }
        dfs(1, 0);
        printf ("%lld\n", Sum[1][n - 1]);
    }
    // while (1);
}

BZOJ 3262 陌上花开 CDQ

Wed, 25 Oct 2017 21:29:20 GMT

题目描述

有n朵花，每朵花有三个属性：花形(s)、颜色(c)、气味(m)，又三个整数表示。现要对每朵花评级，一朵花的级别是它拥有的美丽能超过的花的数量。定义一朵花A比另一朵花B要美丽，当且仅当Sa>=Sb,Ca>=Cb,Ma>=Mb。显然，两朵花可能有同样的属性。需要统计出评出每个等级的花的数量。

输入格式

第一行为N,K (1 <= N <= 100,000, 1 <= K <= 200,000), 分别表示花的数量和最大属性值。以下N行，每行三个整数si, ci, mi (1 <= si, ci, mi <= K)，表示第i朵花的属性

输出格式

包含N行，分别表示评级为0...N-1的每级花的数量。

样例输入

样例输出

提示

1 <= N <= 100,000, 1 <= K <= 200,000

题解

三维偏序
将一个维度作为时间。

比如我令 颜色(c) 为时间维。

那么第一步将除时间(颜色)以外的一个维度排序，
比如说我这里将 花形(s) 排序

那么我们要保证这一维(花形) 时刻有序。

然后我们分治时间(颜色);

我选择的方法是暴力sort，先递归。

那么在分治后左边的花型一定是小于右边的。

所以只要将左右分别按时间排序，对于每一个右边的值，将左边时间比他小的更新到树状数组中。然后查询第三维小于他的个数就可以更新答案了。

一些具体的细节可以看代码实现

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 100005;
const int M = 200005;
struct data
{
    int s, c, m, pos, num, ans;
    bool operator < (const data &a) const
    {
        if (s == a.s && c == a.c) return m < a.m;
        if (s == a.s) return c < a.c;
        return s < a.s; 
    }
}a[N], b[N];
const bool cmp(const data &a, const data &b)
{
    if (a.c == b.c) a.m < b.m;
    return a.c < b.c;
}
int Sum[M], cnt, Color[M], C;
#define lowbit(_) ((_) & (-_))
void add(int x, int c)
{
    for (int i = x; i <= M; i += lowbit(i))
    {
        if (Color[i] != C) Sum[i] = 0;
        Color[i] = C;
        Sum[i] += c;
    }
}
int Query(int x)
{
    int ans = 0;
    for (int i = x; i > 0; i -= lowbit(i))
    {
        if (Color[i] == C)
            ans += Sum[i];
    }
    return ans;
}
void CDQ(int l, int r)
{
    if (l == r) return;
    int mid = l + r >> 1;
    CDQ(l, mid), CDQ(mid + 1, r);
    sort(b + l, b + mid + 1, cmp);
    sort(b + mid + 1, b + r + 1, cmp);
    C++;
    for (int j = mid + 1, i = l; j <= r; j++)
    {
        for (; b[i].c <= b[j].c && i <= mid; i++)
            add(b[i].m, b[i].num);
        b[j].ans += Query(b[j].m);
    }
}
int main()
{
    int n, k;
    scanf ("%d%d", &n, &k);
    for (int i = 1; i <= n; i++){
        scanf ("%d%d%d", &a[i].s, &a[i].c, &a[i].m);
        a[i].pos = i;
    }
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
    {
        if (a[i].c == a[i - 1].c && a[i].s == a[i - 1].s && a[i].m == a[i - 1].m)
            b[cnt].num++;
        else
            b[++cnt] = a[i], b[cnt].num = 1;
    }
    // for (int i = 1; i <= cnt; i++) printf ("%d%c", b[i].pos, " \n"[i == cnt]);
    CDQ(1, cnt);
    // for (int i = 1; i <= cnt; i++) printf ("%d%c", b[i].ans, " \n"[i == cnt]);
    // while(1);
    static int Ans[N];
    for (int i = 1; i <= cnt; i++) Ans[b[i].ans + b[i].num - 1] += b[i].num;
    for (int i = 0; i < n; i++) printf ("%d\n", Ans[i]);
    // while (1);
}

BZOJ 1176 [Balkan2007]Mokia CDQ

Sat, 21 Oct 2017 11:46:59 GMT

Description

维护一个W*W的矩阵，初始值均为S.每次操作可以增加某格子的权值,或询问某子矩阵的总权值.修改操作数M<=160000,询问数Q<=10000,W<=2000000.

Input

第一行两个整数,S,W;其中S为矩阵初始值;W为矩阵大小

接下来每行为一下三种输入之一(不包含引号): "1 x y a" "2 x1 y1 x2 y2" "3" 输入1:你需要把(x,y)(第x行第y列)的格子权值增加a 输入2:你需要求出以左下角为(x1,y1),右上角为(x2,y2)的矩阵内所有格子的权值和,并输出输入3:表示输入结束

Output

对于每个输入2,输出一行,即输入2的答案

Sample Input

Sample Output

3
5

Code

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 800005;
struct Query
{
    int x, y, op, val, id, pos;
    bool operator < (const Query &a) const
    {
        return x == a.x ? op < a.op : x < a.x;
    }
} Ask[MAXN], tmp[MAXN];
int n, m, Ans[MAXN];
#define lowbit(_) ((_)&(-_))
struct BIT
{
    int Sum[2000005];
    void add(int x, int c)
    {
        for (int i = x; i <= n; i += lowbit(i))
            Sum[i] += c;
    }
    int Query(int x)
    {
        int ans = 0;
        for (int i = x; i > 0; i -= lowbit(i))
            ans += Sum[i];
        return ans;
    }
}bit;
void add()
{
    int x1, y1, x2, y2;
    scanf ("%d%d%d%d", &x1, &y1, &x2, &y2);
    ++Ans[0];
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y1 - 1, Ask[m].val = 1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2    , Ask[m].y = y2    , Ask[m].val = 1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y2    , Ask[m].val =-1, Ask[m].op = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2    , Ask[m].y = y1 - 1, Ask[m].val =-1, Ask[m].op = 1;
}
void CDQ(int l, int r)
{
    if (l == r)
        return;
    int mid = l + r >> 1, l1 = l, l2 = mid + 1;
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid && !Ask[i].op)
            bit.add(Ask[i].y, Ask[i].val);
        if (Ask[i].id > mid && Ask[i].op)
            Ans[Ask[i].pos] += Ask[i].val * bit.Query(Ask[i].y);
    }
    for (int i = l; i <= r; i++)
        if (Ask[i].id <= mid && !Ask[i].op)
            bit.add(Ask[i].y, -Ask[i].val);
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid)
            tmp[l1++] = Ask[i];
        else tmp[l2++] = Ask[i];
    }
    for (int i = l; i <= r; i++)
        Ask[i] = tmp[i];
    CDQ(l, mid);
    CDQ(mid + 1, r);
    return;
}
int main()
{
    freopen("mokia.in", "r", stdin);
    freopen("mokia.out", "w", stdout);
    int op;
    scanf ("%d%d", &op, &n);
    while (1)
    {
        scanf ("%d", &op);
        if (op == 1)
        {
            m++;
            scanf ("%d%d%d", &Ask[m].x, &Ask[m].y, &Ask[m].val);
        }
        else if (op == 2)
            add();
        else break;
    }
    for (int i = 1; i <= m; i++)
        Ask[i].id = i;
    sort(Ask + 1, Ask + m + 1);
    CDQ(1 ,m);
    for (int i = 1; i <= Ans[0]; i++)
        printf ("%d\n", Ans[i]);
}

BZOJ 2064 分裂状压DP

Sat, 21 Oct 2017 08:23:31 GMT

Description

背景：和久必分，分久必和。。。题目描述：中国历史上上分分和和次数非常多。。通读中国历史的WJMZBMR表示毫无压力。同时经常搞OI的他把这个变成了一个数学模型。假设中国的国土总和是不变的。每个国家都可以用他的国土面积代替，又两种可能，一种是两个国家合并为1个，那么新国家的面积为两者之和。一种是一个国家分裂为2个，那么2个新国家的面积之和为原国家的面积。 WJMZBMR现在知道了很遥远的过去中国的状态，又知道了中国现在的状态，想知道至少要几次操作（分裂和合并各算一次操作），能让中国从当时状态到达现在的状态。

Input

第一行一个数n1，表示当时的块数，接下来n1个数分别表示各块的面积。第二行一个数n2，表示现在的块，接下来n2个数分别表示各块的面积。

Output

一行一个数表示最小次数。

Sample Input

1 6
3 1 2 3

Sample Output

数据范围：

对于100%的数据，n1,n2<=10，每个数<=50
对于30%的数据，n1,n2<=6，

题解

状压DP 首先可以知道用$n+m-2$次一定可以实现
所以我们考虑减少次数。
如果原集合能分出来一块与新集合中的一块大小相同。
那么这是一个子问题, 他的答案也是$n+m-2$
同样剩下的集合也是如此。这样我们就把答案减小了2。
然后可以看出我们需要尽可能多的将集合分为几部分。每部分对应相等。
这可以用状压DP来解决。
可以将新集合中所有值设为相反数，这样就可以求和为0就可以了。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int a[100];
int S[(1 << 20) + 1], f[(1 << 20) + 1];
int main()
{
    int n, m;
    int cnt = 0;
    scanf ("%d", &n);
    for (cnt = 1; cnt <= n; cnt++)
        scanf ("%d", &a[cnt]);
    scanf ("%d", &m);
    n += m;
    for (; cnt <= n; cnt++)
        scanf ("%d", &a[cnt]), a[cnt] = -a[cnt];
    int N = (1 << n) - 1;
    for (int i = 1; i <= N; i++)
    {
        int j = 0;
        for (j = 1; j <= n; j++)
            if (i & (1 << (j - 1)))
                break;
        S[i] = S[i ^ (1 << (j - 1))] + a[j];
        for (j = 1; j <= n; j++)
            if (i & (1 << (j - 1)))
                f[i] = max(f[i], f[i ^ (1 << (j - 1))] + (!S[i]));
    }
    printf ("%d", n - f[N] * 2);
}

BZOJ 1972 [Sdoi2010]猪国杀

Tue, 10 Oct 2017 21:41:16 GMT

概述
- 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。
- 每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。
游戏目的
- 主猪（MP）：自己存活的情况下消灭所有的反猪。
- 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。
- 反猪（FP）：杀死主猪。
游戏过程
- 游戏开始时候，每个玩家手里都会有 4 张牌，且体力上限和初始体力都是 4 。
- 开始游戏时，从主猪开始，按照逆时针方向（数据中就是按照编号从 1, 2, 3...n, 1... 的顺序）依次行动。
- 每个玩家自己的回合可以分为 4 个阶段
  - 摸牌阶段
    - 从牌堆顶部摸两张牌，依次放到手牌的最右边。
  - 出牌阶段
    - 你可以使用 0 张到任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。
    - 当然，要满足如下规则
      - 如果没有猪哥连弩，每个出牌阶段只能使用一次“杀”来攻击。
      - 任何牌被使用后被弃置（武器是装备上）。
      - 被弃置的牌以后都不能再用，即与游戏无关。
各种牌介绍
- 每张手牌用一个字母表示，字母代表牌的种类。
- 基本牌
  - 『桃(P)』
    - 在自己的回合内，如果自己的体力值不等于体力上限，那么使用一个桃可以为自己补充一点体力；否则不能使用桃。桃只能对自己使用。
    - 在自己的回合外，如果自己的血变为 0 或者更低，那么也可以使用。
  - 『杀(K)』
    - 在自己的回合内，对攻击范围内除自己以外的一名角色使用。
    - 如果没有被『闪』抵消，则造成 1 点伤害。
    - 无论有无武器，杀的攻击范围都是 1。
  - 『闪(D)』
    - 当你受到杀的攻击时，可以弃置一张闪来抵消杀的效果。
- 锦囊牌
  - 『决斗(F)』
    - 出牌阶段，对除自己以外任意一名角色使用，由目标角色先开始，自己和目标角色轮流弃置一张杀，首先没有杀可弃的一方受到1点伤害，另一方视为此伤害的来源。
  - 『南猪入侵(N)』
    - 出牌阶段，对除你以外所有角色使用，按逆时针顺序从使用者下家开始依次结算，除非弃置一张杀，否则受到1点伤害。
  - 『万箭齐发(W)』
    - 和南猪入侵类似，不过要弃置的不是杀而是闪。
  - 『无懈可击(J)』
    - 在目标锦囊生效前抵消其效果。
    - 每次有一张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会。
    - 效果
      - 用于决斗时，决斗无效并弃置。
      - 用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对一个角色产生效果）。
      - 用于无懈可击时，成为目标的无懈可击被无效。
- 装备牌
  - 『猪哥连弩(Z)』
    - 武器，攻击范围 1，出牌阶段你可以使用任意张杀。同一时刻最多只能装一个武器。
    - 如果先前已经有了一把武器，那么之后再装武器的话，会弃置以前的武器来装现在的武器。
特殊事件及概念解释
- 伤害来源
  - 杀、南猪入侵、万箭齐发的伤害来源均是使用该牌的猪。
  - 决斗的伤害来源如上。
- 距离
  - 两只猪的距离定义为沿着逆时针方向间隔的猪数 +1。即初始时 1 和 2 的距离为 1 ，但是 2 和 1 的距离就是 n - 1 。
  - 注意一个角色的死亡会导致一些猪距离的改变。
- 玩家死亡
  - 如果该玩家的体力降到 0 或者更低，并且自己手中没有足够的桃使得自己的体力值回到 1，那么就死亡了，死亡后所有的牌（装备区，手牌区）被弃置、
- 奖励与惩罚
  - 反猪死亡时，最后一个伤害来源处（即使是反猪）立即摸三张牌。
  - 忠猪死亡时，如果最后一个伤害来源是主猪，那么主猪所有装备牌、手牌被弃置。
  - 注意，一旦达成胜利条件，游戏立刻结束，因此即使会摸 3 张牌或者还有牌可以用也不用执行了。
现在，我们已经知道每只猪的角色、手牌，还有牌堆初始情况，并且假设每个角色会按照如下的行为准则进行游戏，你需要做的就是告诉小猪 iPig 最后的结果。
几种行为
- 献殷勤
  - 使用无懈可击挡下南猪入侵、万箭齐发、决斗。
  - 使用无懈可击抵消表敌意。
- 表敌意
  - 对某个角色使用杀、决斗。
  - 使用无懈可击抵消献殷勤。
- 跳忠
  - 即通过行动表示自己是忠猪。
  - 跳忠行动就是对主猪或对某只已经跳忠的猪献殷勤，或者对某只已经跳反的猪表敌意。
- 跳反
  - 即通过行动表示自己是反猪。
  - 跳反行动就是对主猪或对某只已经跳忠的猪表敌意，或者对某只已经跳反的猪献殷勤。
  - 忠猪不会跳反，反猪也不会跳忠。
  - 不管是忠猪还是反猪，能够跳必然跳。
行动准则
- 共性
  - 每个角色如果手里有桃且生命值未满，那么必然吃掉。
  - 有南猪入侵、万箭齐发、必然使用。
  - 有装备必然装上。
  - 受到杀时，有闪必然弃置。
  - 响应南猪入侵或者万箭齐发时候，有杀/闪必然弃置。
  - 不会对未表明身份的猪献殷勤（包括自己）。
- 特性
  - 主猪
    - 主猪会认为没有跳身份，且用南猪入侵/万箭齐发对自己造成伤害的猪是“类反猪”（没伤害到不算，注意“类反猪”并没有表明身份），如果之后跳了，那么主猪会重新认识这只猪。对于每种表敌意的方式，对逆时针方向能够执行到的第一只“类反猪”或者已跳反猪表；如果没有，那么就不表敌意。决斗时会不遗余力弃置杀。
    - 如果能对已经跳忠的猪或自己献殷勤，那么一定献。
    - 如果能够对已经跳反的猪表敌意，那么一定表。
  - 忠猪
    - 对于每种表敌意的方式，对逆时针方向能够执行到的第一只已经跳反的猪表；如果没有，那么就不表敌意。
    - 决斗时，如果对方是主猪，那么不会弃置杀，否则，会不遗余力弃置杀。
    - 如果有机会对主猪或者已经跳忠的猪献殷勤，那么一定献。
  - 反猪
    - 对于每种表敌意的方式，如果有机会则对主猪表，否则，对逆时针方向能够执行到的第一只已经跳忠的猪表；如果没有，那么就不表敌意。
    - 决斗时会不遗余力弃置杀。
    - 如果有机会对已经跳反的猪献殷勤，那么一定献。
限于 iPig 只会用 P++ 语言写 A + B，他请你用 Pigcal(Pascal)、P(C) 或 P++(C++) 语言来帮他预测最后的结果。
输入
- 第一行包含两个正整数n(2 <= n <= 10) 和m( m <= 2000)，分别代表玩家数和牌堆中牌的数量。
- 接下来n行，每行5个字符串，依次表示对第i只猪的角色和初始4张手牌描述。
- 编号为1的肯定是主猪。
- 再接下来一行，一共m个字符串，按照从牌堆顶部到牌堆底部的顺序描述每张牌
- 所有的相邻的两个字符串都严格用1个空格隔开，行尾没有多余空格。
输出
- 输出数据第一行包含一个字符串代表游戏结果。
  - 如果是主猪胜利
    - 那么输出“MP”
    - 否则输出“FP”。
- 接下来n行，第i行是对第i只猪的手牌描述
  - 按照手牌从左往右的顺序输出
  - 相邻两张牌用一个空格隔开，行末尾没有多余空格
  - 如果这只猪已阵亡，那么只要输出“DEAD”即可。
  - 注意如果要输出手牌而没有手牌的话，那么只需输出一个空行。
样例输入

3 10
MP D D F F
ZP N N N D
FP J J J J
F F D D J J F F K D
样例输出

FP
DEAD
DEAD
J J J J J D

题解

题目就是题解

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <list>
#include <cstdlib>
int n, m, T, D_F, Z_D_to_M;
char C[2005];
// #define Log 1
namespace Pig
{
    bool Died[11];
    struct Pig_data
    {
        /*
        Id :
            1: 主猪
            2: 忠猪
            3: 反猪
        */
        std::list<char> Card;
        std::list<char>::iterator it, it2;
        int Identity, Strength;
        bool Equipped, Jump, Similar;
        void init(int Id, char *s)
        {
            Strength = 4, Similar = 0;
            Identity = Id;
            if (Id == 1) Jump = 1;
            for (int i = 1; i <= 4; i++)
                Card.push_back(s[i]);
        }
        void Print(int i)
        {
            it2 = Card.end();
            if (it2 == Card.begin()) 
            {
                if(i != n)
                    printf("\n");
                return;
            }
            it2--;
            for (it = Card.begin(); it != it2; it++)
                printf("%c ", *it);
            printf("%c", *it2);
            if(i != n) printf ("\n");
        }
    }Pig[11];

}
namespace Card
{
    struct Card_Heap_data
    {
        char Card_Heap[2005];
        int h, t;
        void init(char *s, int Num)
        {
            t = Num;
            h = 0;
            for (int i = 1; i <= Num; i++)
                Card_Heap[i] = s[i];
        }
        char Get_Card()
        {
            if (h == t)
                return Card_Heap[h];
            else
                return Card_Heap[++h];
        }
    }Card;
}
namespace Main
{
void Read_init()
{
    #ifdef Log
        printf("===========================================\n Read Start\n=================================\n");
    #endif
    scanf("%d%d", &::n ,&::m);
    char s[5], ID[4];
    for (int i = 1; i <= n; i++)
    {
        scanf ("%s", ID);
        for (int j = 1; j <= 4; j++)
            std::cin >> s[j];
        if (ID[0] == 'M')
            Pig::Pig[i].init(1, s);
        else if (ID[0] == 'Z')
            Pig::Pig[i].init(2, s);
        else
            Pig::Pig[i].init(3, s), T++;
    }
#ifdef Log
    printf("===========================================\n Read Pig Succeed\n=================================\n");
#endif
    memset(Pig::Died, 0, sizeof(Pig::Died));
    for (int i = 1; i <= m; i++)
        std::cin >> C[i];
    #ifdef Log
        printf("===========================================\n Read Card Succeed\n=================================\n");
    #endif
    Card::Card.init(C, m);
#ifdef Log
    printf("===========================================\nCard Init Succeed\n=================================\n");
#endif
}
void Get_Card(int x, int t)
{
#ifdef Log
    printf("Pig %d Get %d Card\n", x, t);
#endif
    while (t--)
    {
        Pig::Pig[x].Card.push_back(Card::Card.Get_Card());
    }
}
int nxt[11];
int next(int x)
{
    if (nxt[x] != 0) return nxt[x];
    for (int i = x + 1; ; i++)
    {
        if (i == n + 1) i = 1;
        if (!Pig::Died[i]) 
            return nxt[x] = i;
    }
}
std::list<char>::iterator it, it2, searchit, eraseit;
bool Over(int &W)
{
    bool No_Fan = 1;
    int now = 0;
    if (Pig::Died[1]) return W = 1, 1;
    else now = 1;
    int Next_Pig = now;
    do
    {
        if (Pig::Pig[Next_Pig].Identity == 3) No_Fan = 0;
        Next_Pig = next(Next_Pig);
    }while (Next_Pig != now);
    if (No_Fan)
        return W = 0, 1;
    else
        return 0;
}
bool Judge(int x, char c, int K_Num, int &t)
{
    if (c == 'P') 
    {
        if (Pig::Pig[x].Strength != 4)
            return t = x, 1;
        else return 0;
    }
    else if (c == 'K')
    {
        if (K_Num && !Pig::Pig[x].Equipped) return 0;
        if (Pig::Pig[x].Identity == 1)
        {
            if (Pig::Pig[next(x)].Similar) return t = next(x), 1;
            if (Pig::Pig[next(x)].Identity == 3 && Pig::Pig[next(x)].Jump)
                return t = next(x), 1;
            else return 0;
        }
        else if (Pig::Pig[x].Identity == 2)
        {
            if (Pig::Pig[next(x)].Identity == 3 && Pig::Pig[next(x)].Jump)
                return t = next(x), 1;
            else return 0;
        }
        else if (Pig::Pig[x].Identity == 3)
        {
            if ((Pig::Pig[next(x)].Identity == 1 || Pig::Pig[next(x)].Identity == 2) && Pig::Pig[next(x)].Jump)
                return t = next(x), 1;
            else return 0;
        }
        else
        {
            printf ("ERROR No Identity\n");
        }
    } 
    else if (c == 'D') return 0;
    else if (c == 'F')
    {
        bool flag = 0;
        int Next_Pig = next(x);
        while (Next_Pig != x)
        {
            if (Pig::Pig[x].Identity == 1)
            {
                if (Pig::Pig[Next_Pig].Similar) return t = Next_Pig, 1;
                if (Pig::Pig[Next_Pig].Identity == 3 && Pig::Pig[Next_Pig].Jump)
                    return t = Next_Pig, 1;
                else goto Restart;
            }
            else if (Pig::Pig[x].Identity == 2)
            {
                if (Pig::Pig[Next_Pig].Identity == 3 && Pig::Pig[Next_Pig].Jump)
                    return t = Next_Pig, 1;
                else goto Restart;
            }
            else if (Pig::Pig[x].Identity == 3)
            {
                if (Pig::Pig[Next_Pig].Identity == 1)
                    return t = Next_Pig, 1;
                else if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[Next_Pig].Jump) 
                {
                    if (!flag) flag = 1, t = Next_Pig;
                    goto Restart;
                }
                else goto Restart;
            }
            else
            {
                printf ("ERROR No Identity\n");
            }
            Restart: Next_Pig = next(Next_Pig);
        }
        if (Pig::Pig[x].Identity == 3 && flag) return 1;
        else return 0;
    }
    else if (c == 'N' || c == 'W')
    {
        return t = -1, 1;
    }
    else if (c == 'J')
        return 0;
    else if (c == 'Z')
        return t = x, 1;
    else
    {
        printf ("ERROR in Card ID\n");
        exit(0);
        return 0;
    }
    return 0;
}
bool Have(char c, int t)// and erase
{
    #ifdef Log
        printf("It's %d to return He have ", t);
        Pig::Pig[t].Print();
    #endif
    for (searchit = Pig::Pig[t].Card.begin(); searchit != Pig::Pig[t].Card.end(); searchit++)
        if (*searchit == c)
        {
            #ifdef Log
                printf("Pig %d Used %c\n", t, c);
            #endif
            return Pig::Pig[t].Card.erase(searchit), 1;
        }
    return 0;
}
bool Need_Wuxie(int x)
{
    if (!Have('J', x)) return 0;
    Pig::Pig[x].Jump = 1;
    Pig::Pig[x].Similar = 0;
    return 1;
}
bool Wuxie(int x, bool op)
{
    int Next_Pig = x;
    do
    {
        if ((op == 0 && Pig::Pig[Next_Pig].Identity == 3) || (op == 1 && Pig::Pig[Next_Pig].Identity != 3))
        {
            if (!Need_Wuxie(Next_Pig)) goto again;
            if (!Wuxie(Next_Pig, op ^ 1)) return 1;
            return 0;
        }
        again: Next_Pig = next(Next_Pig);
    }while (Next_Pig != x);
    return 0;
}
bool Okforwuxie(int x, int t)
{
    if (!Pig::Pig[t].Jump) return 0;
    if (Pig::Pig[t].Identity == 3) return Wuxie(x, 0);
    else return Wuxie(x, 1);
}
void UseM(int x, char c, int t)
{
    if (c == 'K')
    {
        #ifdef Log
            printf("Pig %d use %c to %d\n", x, c, t);
        #endif
        if (Pig::Pig[t].Jump) Pig::Pig[x].Jump = 1;
        if (!Have('D', t))
        {
            #ifdef Log
                printf("Pig %d not have %c\n", t, 'D');
            #endif // Log
            Pig::Pig[t].Strength--;
            #ifdef Log
            printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
            #endif // Log
            if (Pig::Pig[t].Strength == 0)
            {
                if (!Have('P', t))
                {
                    #ifdef Log
                    printf("Pig %d Died\n", t);
                    #endif // Log
                    Pig::Died[t] = 1;
                    memset(nxt, 0, sizeof (nxt));
                    if (Pig::Died[1] == 1) return;
                    if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1) 
                    {
                        Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
                        Z_D_to_M = 1;
                    }
                    if (Pig::Pig[t].Identity == 3) 
                    {
                        D_F++;
                        if (D_F == T) return;
                        Get_Card(x, 3);
                    }
                }
                else
                    Pig::Pig[t].Strength = 1;
            }
        }
        return;
    }
    else if (c == 'P')
        return Pig::Pig[x].Strength++, void(0);
    else if (c == 'F')
    {
        #ifdef Log
            printf("Pig %d use %c to %d\n", x, c, t);
        #endif
        Pig::Pig[x].Jump = 1, Pig::Pig[x].Similar = 0;
        if (Pig::Pig[x].Identity == 1 && Pig::Pig[t].Identity == 2) 
        {
            Pig::Pig[t].Strength--;
            #ifdef Log
            printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
            #endif // Log
            if (Pig::Pig[t].Strength == 0)
            {
                if (!Have('P', t))
                {
                    #ifdef Log
                    printf("Pig %d Died\n", t);
                    #endif // Log
                    Pig::Died[t] = 1;
                    memset(nxt, 0, sizeof (nxt));
                    if (Pig::Died[1] == 1) return;
                    if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1) 
                    {
                        Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
                        Z_D_to_M = 1;
                    }
                    if (Pig::Pig[t].Identity == 3) 
                    {
                        D_F++;
                        if (D_F == T) return;
                        Get_Card(t, 3);
                    }
                }
                else
                    Pig::Pig[t].Strength = 1;
            }
            return;
        }
        if (Okforwuxie(x, t)) return void(0);
        while (1)
        {
            if (!Have('K', t)) 
            {
                Pig::Pig[t].Strength--;
                #ifdef Log
                printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
                #endif // Log
                if (Pig::Pig[t].Strength == 0)
                {
                    if (!Have('P', t))
                    {
                        #ifdef Log
                        printf("Pig %d Died\n", t);
                        #endif // Log
                        Pig::Died[t] = 1;
                        memset (nxt, 0, sizeof (nxt));
                        if (Pig::Died[1] == 1) return;
                        if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1) 
                        {
                            Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
                            Z_D_to_M = 1;
                        }
                        if (Pig::Pig[t].Identity == 3) 
                        {
                            D_F++;
                            if (D_F == T) return;
                            Get_Card(x, 3);
                        }
                    }
                    else
                        Pig::Pig[t].Strength = 1;
                }
                return;
            }
            if (!Have('K', x))
            {
                Pig::Pig[x].Strength--;
                #ifdef Log
                printf("Pig %d HP = %d\n", x, Pig::Pig[x].Strength);
                #endif // Log
                if (Pig::Pig[x].Strength == 0)
                {
                    if (!Have('P', x))
                    {
                        #ifdef Log
                        printf("Pig %d Died\n", x);
                        #endif // Log
                        Pig::Died[x] = 1;
                        memset (nxt, 0, sizeof (nxt));
                        if (Pig::Died[1] == 1) return;
                        if (Pig::Pig[x].Identity == 2 && Pig::Pig[t].Identity == 1) 
                        {
                            Pig::Pig[t].Card.clear(), Pig::Pig[t].Equipped = 0;
                            Z_D_to_M = 1;
                        }
                        if (Pig::Pig[x].Identity == 3) 
                        {
                            D_F++;
                            if (D_F == T) return;
                            Get_Card(t, 3);
                            return;
                        }
                    }
                    else
                        Pig::Pig[x].Strength = 1;
                }
                return;
            }
        }
    }
    else if (c == 'N')
    {
        #ifdef Log
        printf("Pig %d use %c to %d\n", x, c, t);
        #endif
        int Next_Pig = next(x);
        do
        {
            if (Okforwuxie(x, Next_Pig)) goto END1;
            if (!Have('K', Next_Pig))
            {
                Pig::Pig[Next_Pig].Strength--;
                #ifdef Log
                printf("Pig %d HP = %d\n", Next_Pig, Pig::Pig[Next_Pig].Strength);
                #endif // Log
                if (Pig::Pig[Next_Pig].Strength == 0)
                {
                    if (!Have('P', Next_Pig))
                    {
                        #ifdef Log
                        printf("Pig %d Died\n", Next_Pig);
                        #endif // Log
                        memset (nxt, 0, sizeof (nxt));
                        Pig::Died[Next_Pig] = 1;
                        if (Pig::Died[1] == 1) return;
                        if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[x].Identity == 1) 
                        {
                            Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
                            Z_D_to_M = 1;
                        }
                        if (Pig::Pig[Next_Pig].Identity == 3) 
                        {
                            D_F++;
                            if (D_F == T) return;
                            Get_Card(x, 3);
                        }
                    }
                    else
                        Pig::Pig[Next_Pig].Strength = 1;
                }
                if (Pig::Pig[Next_Pig].Identity == 1 && Pig::Pig[x].Jump == 0) Pig::Pig[x].Similar = 1;
            }
            END1:Next_Pig = next(Next_Pig);
        }while (Next_Pig != x);
        return;
    }
    else if (c == 'W')
    {
        #ifdef Log
        printf("Pig %d use %c to %d\n", x, c, t);
        #endif
        int Next_Pig = next(x);
        do
        {
            if (Okforwuxie(x, Next_Pig)) goto END2;
            if (!Have('D', Next_Pig))
            {
                Pig::Pig[Next_Pig].Strength--;
                #ifdef Log
                printf("Pig %d HP = %d\n", Next_Pig, Pig::Pig[Next_Pig].Strength);
                #endif // Log
                if (Pig::Pig[Next_Pig].Strength == 0)
                {
                    if (!Have('P', Next_Pig))
                    {
                        #ifdef Log
                        printf("Pig %d Died\n", Next_Pig);
                        #endif // Log
                        Pig::Died[Next_Pig] = 1;
                        memset (nxt, 0, sizeof (nxt));
                        if (Pig::Died[1] == 1) return;
                        if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[x].Identity == 1) 
                        {
                            Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
                            Z_D_to_M = 1;
                        }
                        if (Pig::Pig[Next_Pig].Identity == 3) 
                        {
                            D_F++;
                            if (D_F == T) return;
                            Get_Card(x, 3);
                        }
                    }
                    else
                        Pig::Pig[Next_Pig].Strength = 1;
                }
                if (Pig::Pig[Next_Pig].Identity == 1 && Pig::Pig[x].Jump == 0) Pig::Pig[x].Similar = 1;
            }
            END2:Next_Pig = next(Next_Pig);
        }while (Next_Pig != x);
        return;
    }
    else if (c == 'Z')
        return Pig::Pig[x].Equipped = 1, void(0);
}
void Use(int x, char c, int t)
{
    UseM(x, c, t);
    // printf("ERROR in Use at Identity, There is no Id in the Pig\n");
}
void Play(int x)
{
    it = Pig::Pig[x].Card.begin();
    int K_Num = 0;
    int Y = D_F;
    for (; it != Pig::Pig[x].Card.end(); it = it2)
    {
        int t = 0;
        if (Judge(x, *it, K_Num, t))
        {
            #ifdef Log
                printf("Pig %d Used %c to %d\n", x, *it, t);
            #endif
            Use(x, *it, t);
            if (Z_D_to_M) return;
            if (*it == 'K') K_Num++;
            Pig::Pig[x].Card.erase(it);
            it2 = Pig::Pig[x].Card.begin();
            if (Pig::Died[1] == 1 || Pig::Died[x] == 1 || D_F == T) return;
        }
        else
        {
            it2 = it;
            it2++;
        }
    }
}
void Run()
{
    int now = 1, W = 0;
    while (!Over(W))
    {
    #ifdef Log
        printf("It is %d Paly, It's Identity is %d ", now, Pig::Pig[now].Identity);
        if (Pig::Pig[now].Jump == 1)
            printf("He Jumped\n");
        else
            printf("He not Jumped\n");
    #endif // Log
        Get_Card(now, 2);
    #ifdef Log
        printf("He has ");
        Pig::Pig[now].Print();
    #endif
        Play(now);
        Z_D_to_M = 0;
        now = next(now);
    }
    if (W == 0)
    {
        printf ("MP\n");
        for (int i = 1; i <= n; i++)
        {
            if (Pig::Died[i])
                printf("DEAD\n");
            else
                Pig::Pig[i].Print(i);
        }
    }
    else
    {
        printf ("FP\n");
        for (int i = 1; i <= n; i++)
        {
            if (Pig::Died[i])
                printf("DEAD\n");
            else
                Pig::Pig[i].Print(i);
        }
    }
}
}
int main()
{
    // freopen("kopk10.in", "r", stdin);
    // freopen("1.out", "w", stdout);
#ifdef Log
    printf("======================================\n Start\n======================================\n");
#endif
    Main::Read_init();
#ifdef Log
    printf("Read Success\n\n");
    printf("======================================\nGame Start\n\n");
#endif
    Main::Run();
}

集训小记

Sun, 01 Oct 2017 15:44:21 GMT

2017 - 10 - 1 Day1

开坑
今天是集训的第一天，上午就考了一场考试；
心中满怀希望，但又充满忐忑
我不知未来如何，但希望过好今天

今天的考试T1很明显是一道找规律的题目，但是因为一些问题，我好久才找到正确的公式。
这道题让我意识到基础的重要性，因为本题用到了高精度，也就是说，如果没有高精度的基础，做本题就无从谈起。
如果打一个高精度调上半天，那考试就没得考了。

然后T2是一道好题，真的好，这道题当场我并没有什么思路。连暴力都没有想出来。就骗了一点分完了。
然后考完试听说输出m就有40。真是个悲哀的故事。
正解是分类讨论，情况很多。

最后T3也是一道思路好题；看到n的范围，一下子想到了状压，但是在仔细一看题，发现状压好像压不下。
想了想也没有办法，正解是按深度状压 + dfs 来减少状态数。真的没有见过这么压的，学习了。

2017 - 10 - 2 Day2

集训的第二天了，早上跟着物理奥赛的跑了个操。
发现信息奥赛的好像只有我来了，一脸尴尬。。。
发现高三的竟然还起上课啊，为他们默哀。
突然感觉自己不孤单了

今天上午的考试 T1一开始没看出来，先做到T2，做完之后想了想T1，发现如果把店转换成线段的话就很好解决了。

T2是一个裸的线段树。感觉复杂度不大对，但是还是过了。

T3是到好题，反正我考场上没做出来，全场平均分1分。
考完后看题解。觉得应该先找规律，在去想怎么打。
其实规律就是一个杨辉三角，累加就可以。二分左右边界。

今天是死在第三题上了，还是思路不够开阔，还有就是A了前两道题之后不太想想第三题了。

2017 - 10 - 3 Day3

早上逃了个操
反正下雨也没跑

昨天晚上考了个试都不是什么难题
T1 直接结论第一个为m第二个为m - 1, 之后就是m - 2的n - 2 次方前面的小数特判一下就过了

T2 是一个简单的树DP 和概率充电器那题很想，上下分别考虑。

T3 读错题了。其他的都没想错。用平衡树维护翻转。然后并查集搞就好了

听说昨天晚上有人浪被逮了。。

2017 - 10 - 4 Day4

上午考了个试， AK了
做完后还有一个多小时，好无聊的，什么也干不了。
然后Rank1，讲了题，然后就放假了，开心。
然后就办域名修好了。蜜汁不能实名认证。

2017 - 10 - 5 Day5

放假在家下午就返校了

2017 - 10 - 6 Day6

该了昨天的题，每一道是简单的。 T1 是一道线段树的题，没想出来，其实正解很暴力。 26次修改即可

T2 很神的一个DP 状态的定义和处理方法很巧，先计算出结果，再让结果是正确的，修正。

T3 一个Trie树上的题需要转化模型。然后是一个DP 。不是很难。

下午又考试。

看到标题有点害怕。

但第一题是个水题，打打就过了。

T2 杜教筛额。。不会啊。。
学习了一下，这道题还是不难的

T3 用线段树维护Treap 上的LCA，又是迷一波
最长上升子序列。

2017 - 10 - 7 Day7

把昨天的题改完了。下午考试又是一个恐怖的标题 HEOI2016 Day0 试题好怕
结果T1 是个水题

T2 读完题？什么玩意。先打个暴力，想了想DP 想到了60分的DP 结果打挂了，好伤心。
正解 $ dp[i][j][k] $表示前i个字符，最长同色长度<=j,最后一个字符是k。 $ s[i][j]=\sum_{k=1}^{m}dp[i][j][k] $ $ dp[i][j][k]=s[i-1][j]*g[i][i][k]-(s[i-j-1][j]-dp[i-j-1][j][k])*g[i-j][i][k] $ 然后就可以DP了

T3 将集合分为重集合和轻集合。轻集合暴力修改，重集合打标记。
然后预处理搞一搞就出来了

2017 - 10 - 8 Day8

上午考试，第三题被很多人水过了
正解好难啊啊啊啊啊啊啊啊啊啊。。。。

T1 直接二分即可。 set

T2 线段树，和前几天做的一道题类似。结果也没想出来。
不过不是很难，改一会就改完了

T3 真是恶心。。。代码(github)
改了好久
思路

这雨下了一天。。

2017 - 10 - 9 Day9

没考好啊。。
T1 是个容斥原理，几乎用了我全部的时间，结果也没推出来。。

T2 是个水题。。。结果都没怎么做。 Tarjan 缩点 + DFS

T3 没人改出来
打了一天的猪国杀

2017 - 10 - 10 Day10

那群被开回家的回来了
T1 将 m 用类似离散的方法搞一搞能出来

T2 裸DP

T3 将后面的几位单独考虑转移就可以了。。

猪国杀终于过了

2017 - 10 - 11 Day11

T1, T2 都是水题 T3 改了好久

2017 - 10 - 12 Day12

两场啊啊啊
上午的题不可做，不可改。说是noi水平
下午的题到是不难

2017 - 10 - 13 Day13

又是两场。。
上午也是不难，第三题没找到规律
下午全场AK

2017 - 10 - 14 Day14

2017 - 10 - 15 Day15

2017 - 10 - 16 Day16

2017 - 10 - 17 Day17

2017 - 10 - 18 Day18

跳了好几天，不太想更了今天复习了一下 Tarjan 开始学2-SAT 有点懵

2017 - 10 - 25 Day25

又是好几天。。
总结一下这几天的情况
这几天脑子有点乱，刷题也刷不动的样子。
考试的题一改改一天。
虽然也有好点的时候，但是心里还是苦啊。
CDQ好懵啊。。
感觉自己少学了好多东西。心累。

未完待续。。。

后缀数组

Tue, 26 Sep 2017 19:43:34 GMT

后缀数组

详解请参见 IOI2009 国家集训队论文

例3：不可重叠最长重复子串（pku1743）

题目链接

先二分答案，判断是否存在两个长度为 k 的子串是相同的，且不重叠。
对于每组后缀，判断后缀的sa值的最大值和最小值之差是否不小于k

Code

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 20010;
int buc[MAXN], wa[MAXN], wb[MAXN], n;
int r[MAXN], sa[MAXN], Rank[MAXN], height[MAXN];
void getheight(int n)
{
    int i, j, k = 0;
    for (i = 0; i < n; i++)
        Rank[sa[i]] = i;
    for (i = 0; i < n; height[Rank[i++]] = k)
        for (k ? k-- : 0, j = sa[Rank[i] - 1]; r[i + k] == r[j + k]; k++)
            ;
    return;
}
bool cmp(int *c, int a, int b, int d)
{
    return c[a] == c[b] && c[a + d] == c[b + d];
}
void da(int n, int m = 320)
{
    // for(int i=0;i<n;i++)printf("%d  %d\n",i,r[i]);
    int i, j, p, *x = wa, *y = wb, *t;
    for (i = 0; i < m; i++)
        buc[i] = 0;
    for (i = 0; i < n; i++)
        buc[x[i] = r[i]]++;
    for (i = 1; i < m; i++)
        buc[i] += buc[i - 1];
    for (i = n - 1; ~i; i--)
        sa[--buc[x[i]]] = i;
    for (j = 1, p = 1; p < n; j *= 2, m = p)
    {
        for (i = n - j, p = 0; i < n; i++)
            y[p++] = i;
        for (i = 0; i < n; i++)
            if (sa[i] >= j)
                y[p++] = sa[i] - j;
        for (i = 0; i < m; i++)
            buc[i] = 0;
        for (i = 0; i < n; i++)
            buc[x[y[i]]]++;
        for (i = 1; i < m; i++)
            buc[i] += buc[i - 1];
        for (i = n - 1; ~i; i--)
            sa[--buc[x[y[i]]]] = y[i];
        for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
    }
    // for(int i=0;i<n;i++)
    //     printf("%d  %d\n",i,sa[i]);
    getheight(n);
    return;
}
bool Judge(int mid)
{
    int Min = 0x3f3f3f3f, Max = -0x3f3f3f3f;
    for (int i = 2; i <= n; i++)
    {
        if (height[i] < mid)
            Min = 0x3f3f3f3f, Max = -0x3f3f3f3f;
        else
        {
            Min = min(Min, min(sa[i - 1], sa[i]));
            Max = max(Max, max(sa[i - 1], sa[i]));
            if (Max - Min > mid)
                return 1;
        }
    }
    return 0;
}
int a[MAXN];
int main()
{
    while (~scanf("%d", &n) && n)
    {
        for (int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        n--;
        for (int i = 0; i < n; i++)
            r[i] = a[i + 1] - a[i] + 88;
        r[n] = 0;
        da(n + 1);
        int l = 0, r = (n >> 1) + 1, ans = 0;
        while (l < r)
        {
            int m = l + r >> 1;
            if(Judge(m))
                ans = m, l = m + 1;
            else
                r = m;
        }
        if (ans >= 4) printf("%d\n", ans + 1);
        else printf("0\n");
    }
}

例4：可重叠的 k 次最长重复子串（pku3261）

题目链接

先二分答案，然后将后缀分成若干组。判断有没有一个组的后缀个数不小于k。

Code

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 2000005;
int buc[MAXN], wa[MAXN], wb[MAXN], n, K;
int r[MAXN], sa[MAXN], Rank[MAXN], height[MAXN];
void GetHeight(int n)
{
    int i, j, k = 0;
    for (i = 0; i < n; i++)
        Rank[sa[i]] = i;
    for (i = 0; i < n; height[Rank[i++]] = k)
        for (k ? k-- : 0, j = sa[Rank[i] - 1]; r[i + k] == r[j + k]; k++)
            ;
    return;
}
bool cmp(int *c, int a, int b, int d)
{
    return c[a] == c[b] && c[a + d] == c[b + d];
}
void da(int n, int m = 1000000)
{
    int i, j, p, *x = wa, *y = wb, *t;
    for (i = 0; i < m; i++)
        buc[i] = 0;
    for (i = 0; i < n; i++)
        buc[x[i] = r[i]]++;
    for (i = 1; i < m; i++)
        buc[i] += buc[i - 1];
    for (i = n - 1; ~i; i--)
        sa[--buc[x[i]]] = i;
    for (j = 1, p = 1; p < n; j *= 2, m = p)
    {
        for (i = n - j, p = 0; i < n; i++)
            y[p++] = i;
        for (i = 0; i < n; i++)
            if (sa[i] >= j)
                y[p++] = sa[i] - j;
        for (i = 0; i < m; i++)
            buc[i] = 0;
        for (i = 0; i < n; i++)
            buc[x[y[i]]]++;
        for (i = 1; i < m; i++)
            buc[i] += buc[i - 1];
        for (i = n - 1; ~i; i--)
            sa[--buc[x[y[i]]]] = y[i];
        for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
    }
    GetHeight(n);
    return;
}
bool Judge(int mid)
{
    int l = 0;
    for (int i = 2; i <= n; i++)
    {
        if (height[i] < mid)
            l = 0;
        else
        {
            l++;
            if(l + 1 >= K) return 1;
        }
    }
    return 0;
}
int main()
{
    scanf("%d%d", &n, &K);
    for (int i = 0; i < n; i++)
        scanf("%d", &r[i]);
    da(n + 1);
    int l = 0, r = (n >> 1) + 1, ans = 0;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (Judge(mid))
            ans = mid, l = mid + 1;
        else
            r = mid;
    }
    printf("%d", ans);
}

未完待续。。。

BZOJ 2827 千山鸟飞绝 Treap

Sun, 24 Sep 2017 18:27:12 GMT

题目描述

话说有一天doyouloveme和vfleaking到山里玩。谁知doyouloveme刚刚进山，所有的鸟儿竟被他的神犇气场给惊得全部飞走了。vfleaking顿时膜拜不已。
这时鸟王用鸟语说道：“!@#$%……?”安抚了一下众鸟的情绪。鸟王生性好斗，作出了一个决定——要排鸟布阵把刚才吓到它们的人类赶出山去。
 每只鸟都有一个编号，都有一个威武值。每秒钟鸟王都会发一个命令，编号为v的鸟飞到(x,y)去（坐标系原点是山顶，坐标单位为鸟爪）。鸟飞得很快，一秒之内就飞到了，可以看作是瞬间移动。如果编号为v的鸟和编号为u的鸟某一时刻处在同一位置，它们就会互相鼓励，增加各自的士气值和团结值。一只鸟的士气值等于此刻与它处在同一位置的鸟中的威武值的最大值，团结值等于此刻与它处在同一位置的鸟的只数。如果每一时刻都没有鸟与它处在同一位置，则士气值和团结值都为0。要注意自己不能鼓励自己，计算士气值和团结值时不能算上自己。 t秒钟后，doyouloveme目测出了现在每只鸟的战斗力，于是感叹了一句：“不妙，我们得走了。”
正所谓团结的鸟儿一个顶俩，所以doyouloveme这样描述战斗力：一只鸟战斗力值等于它在0到t秒中士气值的最大值与团结值的最大值的乘积。注意不是乘积的最大值，而是最大值的乘积。
vfleaking很想知道现在每只鸟的战斗力，但是他当然不会啦，于是他把这个任务交给了你来完成。

输入

第一行一个数n，代表鸟的只数。（鸟王那家伙你可以完全忽视掉）
接下来n行，每行三个整数w,x,y描述每只鸟的威武值和初始坐标。第i+1行描述编号为i的鸟。
接下来一行有一个数t，代表经过时间ts。
接下来t行，每行三个整数v,x,y描述鸟王每秒的命令。

输出

一共n行，每行一个数，代表每只鸟的战斗力。

样例输入

样例输出

提示

对于样例的解释：首先5只鸟的位置为(1,1),(1,2),(4,4),(0,1),(2,3)，士气和团结值都是0。
鸟1飞到了(1,2)，于是鸟1和鸟2互相鼓励，鸟1士气变为3，鸟2士气变为1。鸟1鸟2的团结值变为1。
然后鸟2飞到(4,4)，与鸟3互相鼓励，鸟2士气变为4，鸟3士气变为3。鸟2与鸟3的团结值变为1。
鸟2然后飞到了(4,3)，一个没有鸟的地方。于是士气和团结值都变为了0。
接下来鸟3和鸟5都飞到了鸟4的位置，于是三只鸟互相鼓励，鸟4、鸟5士气变为4，鸟3士气仍为3。鸟3、鸟4、鸟5的团结值都变为2。
于是大家的战斗力：
鸟1：3 * 1 = 3
鸟2：4 * 1 = 4
鸟3：3 * 2 = 6
鸟4：4 * 2 = 8
鸟5：4 * 2 = 8
1≤n≤30000 0≤t≤300000
坐标范围为整数，且不超过INT_MIN~INT_MAX
威武值为不超过INT_MAX的非负整数。

题解

哈希加Treap

把每一个点Hash对应的一棵Treap上
在插入和删除的时候不断的打标记跟新
注意不要漏情况
在最后的时候要把所有的标记都推下去
然后就出来了
细节很多调了好久

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int Max_Morale[30005], Max_Solidarity[30005];
struct Point
{
    int x, y;
    Point(int a = 0, int b = 0)
    {
        x = a, y = b;
    }
    bool operator==(const Point &a) const
    {
        return x == a.x && y == a.y;
    }
};
struct data
{
    int x, ID;
    data(int a = 0, int b = 0)
    {
        x = a, ID = b;
    }
    bool operator>(const data &a) const
    {
        return x == a.x ? ID > a.ID : x > a.x;
    }
    bool operator<=(const data &a) const
    {
        return !(*this > a);
    }
};
struct Treap
{
    struct Node
    {
        int s, key, Max_Num, Max_Size;
        data x;
        Node *ch[2];
        Node(data sa)
        {
            ch[0] = ch[1] = NULL;
            s = 1, x = sa, key = rand();
            Max_Num = Max_Size = 0;
        }
#define size(_) ((_) ? (_)->s : 0)
        void Pushup()
        {
            s = size(ch[0]) + size(ch[1]) + 1;
        }
        void Pushdown()
        {
            if (ch[0])
            {
                ch[0]->Max_Num = max(ch[0]->Max_Num, Max_Num);
                ch[0]->Max_Size = max(ch[0]->Max_Size, Max_Size);
                Max_Morale[ch[0]->x.ID] = max(Max_Morale[ch[0]->x.ID], ch[0]->Max_Num);
                Max_Solidarity[ch[0]->x.ID] = max(Max_Solidarity[ch[0]->x.ID], ch[0]->Max_Size);
            }
            if (ch[1])
            {
                ch[1]->Max_Num = max(ch[1]->Max_Num, Max_Num);
                ch[1]->Max_Size = max(ch[1]->Max_Size, Max_Size);
                Max_Morale[ch[1]->x.ID] = max(Max_Morale[ch[1]->x.ID], ch[1]->Max_Num);
                Max_Solidarity[ch[1]->x.ID] = max(Max_Solidarity[ch[1]->x.ID], ch[1]->Max_Size);
            }
            Max_Num = Max_Size = 0;
        }
    } * root;
    Treap()
    {
        root = NULL;
    }
    Node *Merge(Node *A, Node *B)
    {
        if (!A)
            return B;
        if (!B)
            return A;
        if (A->key < B->key)
        {
            A->Pushdown();
            A->ch[1] = Merge(A->ch[1], B);
            A->Pushup();
            return A;
        }
        else
        {
            B->Pushdown();
            B->ch[0] = Merge(A, B->ch[0]);
            B->Pushup();
            return B;
        }
    }
    typedef pair<Node *, Node *> DNode;
    DNode Split(Node *rt, int k)
    {
        if (!rt)
            return DNode(NULL, NULL);
        DNode o;
        rt->Pushdown();
        if (size(rt->ch[0]) >= k)
        {
            o = Split(rt->ch[0], k);
            rt->ch[0] = o.second;
            rt->Pushup();
            o.second = rt;
        }
        else
        {
            o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
            rt->ch[1] = o.first;
            rt->Pushup();
            o.first = rt;
        }
        return o;
    }
    Node *kth(int k)
    {
        DNode x = Split(root, k - 1);
        DNode y = Split(x.second, 1);
        Node *ans = y.first;
        root = Merge(Merge(x.first, ans), y.second);
        return ans;
    }
    int Rank(Node *rt, data x)
    {
        if (!rt)
            return 0;
        return x <= rt->x ? Rank(rt->ch[0], x) : Rank(rt->ch[1], x) + size(rt->ch[0]) + 1;
    }
    void Insert(data x)
    {
        int k = Rank(root, x);
        if (root)
        {
            root->Max_Size = max(root->Max_Size, size(root));
            root->Max_Num = max(root->Max_Num, x.x);
            Max_Morale[root->x.ID] = max(root->Max_Num, Max_Morale[root->x.ID]);
            Max_Solidarity[root->x.ID] = max(root->Max_Size, Max_Solidarity[root->x.ID]);
        }
        DNode y = Split(root, k);
        Node *n = new Node(x);
        root = Merge(Merge(y.first, n), y.second);
    }
    void remove(data x)
    {
        int k = Rank(root, x);
        DNode a = Split(root, k);
        DNode b = Split(a.second, 1);
        delete b.first;
        root = Merge(a.first, b.second);
    }
};
#define Hash_MOD 76543
#define Hash_MOD_x 9991
#define Hash_MOD_y 7307
int p = 0;
struct Hash_Table
{
    int first[76545];
    struct Link
    {
        Treap *rt;
        Point t;
        int next;
    } v[400000];
    Hash_Table()
    {
        memset(first, -1, sizeof(first));
    }
    void Push(int u, Point now, Treap *x)
    {
        v[p].rt = x;
        v[p].t = now;
        v[p].next = first[u];
        first[u] = p++;
    }
    Treap *&operator[](Point x)
    {
        int Hash = (((x.x % Hash_MOD_x) + Hash_MOD_x) % Hash_MOD_x) * (((x.y % Hash_MOD_y) + Hash_MOD_y) % Hash_MOD_y) % Hash_MOD;
        for (int i = first[Hash]; i != -1; i = v[i].next)
            if (v[i].t == x)
                return v[i].rt;
        Push(Hash, x, new Treap);
        return v[first[Hash]].rt;
    }
} Hash;
#define X(_) ((_) ? (_)->x : 0)

Point bird[30005];
int Num[30005];
int main()
{
    int n;
    scanf("%d", &n);
    int a, b, c;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        Max_Morale[i] = max(Max_Morale[i], X(Hash[Point(b, c)]->kth(size(Hash[Point(b, c)]->root))).x);
        Max_Solidarity[i] = max(Max_Solidarity[i], size(Hash[Point(b, c)]->root));
        Hash[Point(b, c)]->Insert(data(a, i));
        bird[i] = Point(b, c);
        Num[i] = a;
    }
    int m;
    scanf("%d", &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        Hash[bird[a]]->remove(data(Num[a], a));
        Max_Morale[a] = max(Max_Morale[a], X(Hash[Point(b, c)]->kth(size(Hash[Point(b, c)]->root))).x);
        Max_Solidarity[a] = max(Max_Solidarity[a], size(Hash[Point(b, c)]->root));
        Hash[Point(b, c)]->Insert(data(Num[a], a));
        bird[a] = Point(b, c);
    }
    for (int i = 1; i <= n; i++)
        Hash[bird[i]]->remove(data(Num[i],i));
    for (int i = 1; i <= n; i++)
        printf("%lld\n", (long long)Max_Morale[i] * Max_Solidarity[i]);
    // while(1);
}

BZOJ 3211 花神游历各国

Tue, 19 Sep 2017 19:09:52 GMT

Description

Input

Output

每次x=1时，每行一个整数，表示这次旅行的开心度

Sample Input

Sample Output

101
11
11

题解

本题和上帝造题的七分钟是一样的

但我的程序没有过啊
打的比较傻

其实只要维护一个值就可以了

用一个flag标记是否不变

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#ifndef LL
#define LL long long
#endif
#define lch l, m, rt << 1
#define rch m + 1, r, rt << 1 | 1
const int N = 100005;
LL Sum[N << 2];
bool flag[N << 2];
void PushUp(int rt)
{
	Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1];
	flag[rt] = flag[rt << 1] & flag[rt << 1 | 1];
}
void buildtree(int l, int r, int rt)
{
	if(l == r)
	{
		scanf("%lld", &Sum[rt]);
		if(Sum[rt] <= 1)
			flag[rt] = 1;
		return;
	}
	int m = l + r >> 1;
	buildtree(lch);
	buildtree(rch);
	PushUp(rt);
}
void Update(int L, int R, int l, int r, int rt)
{
	if(flag[rt])
		return;
	if(l == r)
	{
		Sum[rt] = sqrt(Sum[rt]);
		if(Sum[rt] <= 1)
			flag[rt] = 1;
		return;
	}
	int m = l + r >> 1;
	if (L <= m) Update(L, R, lch);
	if (R > m) Update(L, R, rch);
	PushUp(rt);
}
LL Query(int L, int R, int l, int r, int rt)
{
	if(L <= l && R >= r)
		return Sum[rt];
	int m = l + r >> 1;
	LL ans = 0;
	if (L <= m) ans += Query(L, R, lch);
	if (R > m) ans += Query(L, R, rch);
	return ans;
}
int main()
{
	int n;
	scanf("%d", &n);
	buildtree(1, n, 1);
	int m;
	scanf("%d", &m);
	while (m--)
	{
		int op, l, r;
		scanf("%d%d%d", &op, &l, &r);
		if(l > r)
			swap(l, r);
		if (op == 1)
		{
			printf("%lld\n", Query(l, r, 1, n, 1));
		}
		else
			Update(l, r, 1, n, 1);
	}
}

BZOJ 1770 [Usaco2009 Nov]lights 燈折半搜索

Sun, 17 Sep 2017 21:09:37 GMT

题目描述

贝希和她的闺密们在她们的牛棚中玩游戏。但是天不从人愿，突然，牛棚的电源跳闸了，所有的灯都被关闭了。贝希是一个很胆小的女生，在伸手不见拇指的无尽的黑暗中，她感到惊恐，痛苦与绝望。她希望您能够帮帮她，把所有的灯都给重新开起来！她才能继续快乐地跟她的闺密们继续玩游戏！  牛棚中一共有N（1 <= N <= 35）盏灯，编号为1到N。这些灯被置于一个非常复杂的网络之中。有M（1 <= M <= 595）条很神奇的无向边，每条边连接两盏灯。每盏灯上面都带有一个开关。当按下某一盏灯的开关的时候，这盏灯本身，还有所有有边连向这盏灯的灯的状态都会被改变。状态改变指的是：当一盏灯是开着的时候，这盏灯被关掉；当一盏灯是关着的时候，这盏灯被打开。问最少要按下多少个开关，才能把所有的灯都给重新打开。数据保证至少有一种按开关的方案，使得所有的灯都被重新打开。

输入

＊第一行：两个空格隔开的整数：N和M。

＊第二到第M+1行：每一行有两个由空格隔开的整数，表示两盏灯被一条无向边连接在一起。没有一条边会出现两次。

输出

第一行：一个单独的整数，表示要把所有的灯都打开时，最少需要按下的开关的数目。

样例输入

輸入細節：

一共有五盞燈。燈1、燈4和燈5都連接著燈2和燈3。

样例输出

輸出細節：

按下在燈1、燈4和燈5上面的開關。

题解

【折半搜索】
将需要搜索的元素分为不关联的两个部分，分别搜索

在本题中 N的范围有35如果直接搜的话$2^35$会T的很惨
所以我们将N分为前后两部分
现将前mid个搜出来，记录每个状态集合的最小的答案
之后出来后mid + 1到n搜完后加上他的补集跟新答案

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
long long A[36], full, bin[37];
int Min = 0x3f, n, m;
map<long long, int> Mp;
void dfs1(int x, long long now, int k)
{
	if(x == m + 1)
	{
		if(now == full)
			Min = min(k, Min);
		int t = Mp[now];
		if(!t || t > k)
			Mp[now] = k;
		return;
	}
	dfs1(x + 1, now, k);
	dfs1(x + 1, now^A[x], k + 1);
}
void dfs2(int x, long long now, int k)
{
	if(x == n + 1)
	{
		if(now == full)
			Min = min(k, Min);
		int t = Mp[full - now];
		if(!t)
			return;
		Min = min(t + k, Min);
		return;
	}
	dfs2(x + 1, now, k);
	dfs2(x + 1, now^A[x], k + 1);
}
int main()
{
	// freopen("lights.in","r",stdin);
	// freopen("lights.out","w",stdout);
	int c;
	scanf("%d%d", &n, &c);
	bin[1] = 1;
	for (int i = 2; i < 37; i++)
		bin[i] = bin[i - 1] << 1;
	int a, b;
	for (int i = 1; i <= c; i++)
	{
		scanf("%d%d", &a, &b);
		A[a] += bin[b];
		A[b] += bin[a];
	}
	for (int i = 1; i <= n; i++)
		A[i] += bin[i];
	full = bin[n + 1] - 1;
	m = n >> 1;
	dfs1(1, 0, 0);
	dfs2(m + 1, 0, 0);
	printf("%d", Min);
}

[NOIP2004] 虫食算

Sun, 17 Sep 2017 16:42:37 GMT

题目描述

所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子：

43#98650#45
+ 8468#6633
44445506978

其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。现在，我们对问题做两个限制：首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中三个数都有N位，允许有前导的0。其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的。我们将相同的数字用相同的字母表示，不同的数字用不同的字母表示。如果这个算式是N进制的，我们就取英文字母表中的前N个大写字母来表示这个算式中的0到N-1这N个不同的数字（但是这N个字母并不一定顺序地代表0到N-1）。输入数据保证N个字母分别至少出现一次。

BADC
+ CBDA
DCCC

上面的算式是一个4进制的算式。很显然，我们只要让ABCD分别代表0123，便可以让这个式子成立了。你的任务是，对于给定的N进制加法算式，求出N个不同的字母分别代表的数字，使得该加法算式成立。输入数据保证有且仅有一组解。

输入

包含4行。第一行有一个正整数N（N <= 26），后面的3行每行有一个由大写字母组成的字符串，分别代表两个加数以及和。这3个字符串左右两端都没有空格，从高位到低位，并且恰好有N位。

输出

包含一行。在这一行中，应当包含唯一的那组解。解是这样表示的：输出N个数字，分别表示A，B，C……所代表的数字，相邻的两个数字用一个空格隔开，不能有多余的空格。

样例输入

5
ABCED
BDACE
EBBAA

样例输出

1 0 3 4 2

题解

从后向前从大到小倒着搜
分8种情况讨论
打的是真爽

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;
char a[30], b[30], c[30];
bool mark[30];
int map[300], n, ans;
void dfs(int pos, int y)
{
    ans++;
    //printf("%d\n", ans);
    if(pos == 0)
    {
        for (int i = 'A'; i < 'A' + n; i++)
            printf("%d ",map[i]);
        exit(0);
    }
    if(map[a[pos]] != -1 && map[b[pos]] != -1 && map[c[pos]] != -1)
    {
        if((map[a[pos]] + map[b[pos]] + y) % n != map[c[pos]])
            return;
        else
            dfs(pos - 1, (map[a[pos]] + map[b[pos]] + y) / n);
    }
    else if (map[a[pos]] != -1 && map[b[pos]] != -1)
    {
        if(mark[(map[a[pos]] + map[b[pos]] + y) % n])
            return;
        else
        {
            map[c[pos]] = (map[a[pos]] + map[b[pos]] + y) % n;
            mark[(map[a[pos]] + map[b[pos]] + y) % n] = 1;
            dfs(pos - 1, (map[a[pos]] + map[b[pos]] + y) / n);
            mark[(map[a[pos]] + map[b[pos]] + y) % n] = 0;
            map[c[pos]] = -1;
        }
    }
    else if (map[a[pos]] != -1 && map[c[pos]] != -1)
    {
        int now = map[c[pos]] + n - y - map[a[pos]];
        if(mark[now % n])
            return;
        map[b[pos]] = now % n;
        mark[now % n] = 1;
        dfs(pos - 1, (now % n) == now ? 1 : 0);
        map[b[pos]] = -1;
        mark[now % n] = 0;
    }
    else if (map[b[pos]] != -1 && map[c[pos]] != -1)
    {
        int now = map[c[pos]] + n - y - map[b[pos]];
        if(mark[now % n])
            return;
        map[a[pos]] = now % n;
        mark[now % n] = 1;
        dfs(pos - 1, (now % n) == now ? 1 : 0);
        map[a[pos]] = -1;
        mark[now % n] = 0;
    }
    else if(map[a[pos]] != -1)
    {
        for (int i = 0; i < n; i++)
            if(!mark[i] && !mark[(map[a[pos]] + i + y) % n])
            {
                map[b[pos]] = i;
                map[c[pos]] = (map[a[pos]] + i + y) % n;
                mark[i] = 1;
                mark[(map[a[pos]] + i + y) % n] = 1;
                dfs(pos - 1, (map[a[pos]] + i + y) / n);
                map[b[pos]] = -1;
                map[c[pos]] = -1;
                mark[i] = 0;
                mark[(map[a[pos]] + i + y) % n] = 0;
            }
    }
    else if(map[b[pos]] != -1)
    {
        for (int i = 0; i < n; i++)
            if(!mark[i] && !mark[(map[b[pos]] + i + y) % n])
            {
                map[a[pos]] = i;
                map[c[pos]] = (map[b[pos]] + i + y) % n;
                mark[i] = 1;
                mark[(map[b[pos]] + i + y) % n] = 1;
                dfs(pos - 1, (map[b[pos]] + i + y) / n);
                map[a[pos]] = -1;
                map[c[pos]] = -1;
                mark[i] = 0;
                mark[(map[b[pos]] + i + y) % n] = 0;
            }
    }
    else if(map[c[pos]] != -1)
    {
        for (int i = 0; i < n; i++)
        {
            if(!mark[i] && !mark[(map[c[pos]] + n - i - y) % n])
            {
                map[a[pos]] = i;
                map[b[pos]] = (map[c[pos]] + n - i - y) % n;
                mark[i] = 1;
                mark[(map[c[pos]] + n - i - y) % n] = 1;
                dfs(pos - 1, ((map[c[pos]] + n - i - y) % n == (map[c[pos]] + n - i - y)));
                map[a[pos]] = -1;
                map[b[pos]] = -1;
                mark[i] = 0;
                mark[(map[c[pos]] + n - i - y) % n] = 0;
            }
        }
    }
    else
    {
        // printf("\\\\\n");
        for (int i = n - 1; i >= 0; i--)
        {
            if(mark[i]) continue;
            mark[i] = 1;
            map[a[pos]] = i;
            // printf("------__\n");
            for (int j = n - 1; j >= 0; j--)
            {
                if(!mark[j] && !mark[(i + j + y) % n])
                {
                    // printf("===\n");
                    mark[j] = mark[(i + j + y) % n] = 1;
                    map[b[pos]] = j;
                    map[c[pos]] = (i + j + y) % n;
                    dfs(pos - 1, (i + j + y) / n);
                    mark[j] = mark[(i + j + y) % n] = 0;
                    map[b[pos]] = -1;
                    map[c[pos]] = -1;
                }
                else if (mark[j] && mark[(i + j + y) % n] && (j == map[b[pos]]) && ((i + j + y) % n == map[c[pos]]))
                {
                    dfs(pos - 1, (i + j + y) / n);
                }
                else if (mark[j] && (j == map[b[pos]]) && !mark[(i + j + y) % n])
                {
                    // printf("----\n");
                    mark[(i + j + y) % n] = 1;
                    map[c[pos]] = (i + j + y) % n;
                    dfs(pos - 1, (i + j + y) / n);
                    map[c[pos]] = -1;
                    mark[(i + j + y) % n] = 0;
                }
            }
            map[a[pos]] = -1;
            mark[i] = 0;
        }
    }
}
int main()
{
    // freopen("alpha.in","r",stdin);
    // freopen("alpha.out","w",stdout);
    scanf("%d", &n);
    scanf("%s%s%s", a + 1, b + 1, c + 1);
    for (int i = 'A'; i < 'A' + n; i++)
        map[i] = -1;
    dfs(n, 0);
}

NOIP模拟超级树

Fri, 15 Sep 2017 19:18:35 GMT

3.1 描述

一棵k-超级树可按如下方法得到：取一棵深度为k的满二叉树，对每个节点，向它的所有祖先连边（如果这条边不存在的话）。例如，下图是一个4-超级树的例子：  现在你的任务是统计一棵k-超级树中有多少条每个节点最多经过一次的不同有向路径。两条路径被认为不同，当且仅当它们经过的节点的集合不同，或经过的节点的顺序不同。由于答案可能很大，请输出总路径数对mod取模后的结果。

3.2 输入

一行两个整数k、mod，意义见上。

3.3 输出

一行一个整数，代表答案

样例

输入	输出
2 100	9
3 1000	245
20 998244353	450500168

样例解释：对第一组样例，将节点如图编号，共有9条不同的路径：1, 2, 3, 1− 2, 2 − 1, 1 − 3, 3 − 1, 2 − 1 − 3, 3 − 1 − 2。

限制与约定

对于10%的数据，k ≤ 4。对于40%的数据，k ≤ 10。对于60%的数据，k ≤ 100。另有10%的数据，mod = 998244353。对于所有数据，1 ≤ k ≤ 300，1 ≤ mod ≤ 109。

题解

考虑dp[i][j]表示一棵i-超级树，有j条点不重复的路径的方案数。对于第二维表示有j条路径他们不相交的方案数这记num=dp[i][l]*dp[i][r]

dp[i+1][l+r]+=num  
dp[i+1][l+r+1]+=num  
dp[i+1][l+r]+=2*num*(l+r)  
dp[i+1][l+r-1]+=2*num*l*r  
dp[i+1][l+r-1]+=num*(l*(l-1)+r*(r-1))

dp[1][0]=dp[1][1]=1
答案为dp[k][1]

因为我们发现每次转移的时候j最多会减1
所以我们只需要前k-i+1个状态
只DP这些状态就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
long long f[305][305];
int MOD;
int main()
{
	int k;
	scanf("%d%d", &k, &MOD);
	f[1][0] = f[1][1] = 1 % MOD;
	for (int i = 1; i < k; i++)
	{
		for (int l = 0; l <= k - i + 1; l++)
			for (int r = 0; r <= k - i + 1; r++)
			{
				long long num = f[i][l] * f[i][r] % MOD;
				if (r + l <= k - i)
				{
					f[i + 1][r + l] = (f[i + 1][r + l] + num) % MOD;
					f[i + 1][r + l] = (f[i + 1][r + l] + 2 * num * (l + r) % MOD) % MOD;
				}
				if (r + l + 1 <= k - i)
					f[i + 1][r + l + 1] = (f[i + 1][r + l + 1] + num) % MOD;
				if (r + l - 1 <= k - i)
				{
					f[i + 1][r + l - 1] = (f[i + 1][r + l - 1] + 2 * num * l * r % MOD) % MOD;
					f[i + 1][r + l - 1] = (f[i + 1][r + l - 1] + num * (l * (l - 1) + r * (r - 1)) % MOD) % MOD;
				}
			}
	}
	printf("%lld", f[k][1]);
}

[ZJOI2007]矩阵游戏

Tue, 22 Aug 2017 17:12:21 GMT

题目描述

小Q是一个非常聪明的孩子，除了国际象棋，他还很喜欢玩一个电脑益智游戏——矩阵游戏。矩阵游戏在一个N *N黑白方阵进行（如同国际象棋一般，只是颜色是随意的）。每次可以对该矩阵进行两种操作：行交换操作：选择矩阵的任意两行，交换这两行（即交换对应格子的颜色）列交换操作：选择矩阵的任意行列，交换这两列（即交换对应格子的颜色）  游戏的目标，即通过若干次操作，使得方阵的主对角线(左上角到右下角的连线)上的格子均为黑色。对于某些关卡，小Q百思不得其解，以致他开始怀疑这些关卡是不是根本就是无解的！！于是小Q决定写一个程序来判断这些关卡是否有解。

输入

第一行包含一个整数T，表示数据的组数。接下来包含T组数据，每组数据第一行为一个整数N，表示方阵的大小；接下来N行为一个N*N的01矩阵（0表示白色，1表示黑色）。

输出

输出文件应包含T行。对于每一组数据，如果该关卡有解，输出一行Yes；否则输出一行No。

样例输入

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

样例输出

No
Yes

【数据规模】

对于100%的数据，N ≤ 200

题解

我们发现在同一行或同一列的一直在同一行或同一列。
所以这道题就是要求是否能找到不同行列的一个匹配覆盖n个点

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct edge
{
    int END, next;
}v[40005];
int first[205],p;
void add(int a,int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int link[205];
bool vis[205];
int find(int x)
{
    for (int i = first[x]; i != -1; i = v[i].next)
    {
        if(!vis[v[i].END])
        {
            vis[v[i].END] = 1;
            if(link[v[i].END]==-1||find(link[v[i].END]))
            {
                link[v[i].END] = x;
                return 1; 
            }
        }
    }
    return 0;
}
int main()
{
    int T, a;
    scanf("%d", &T);
    while (T--)
    {
        memset(first, -1, sizeof(first));
        p = 0;
        memset(link, -1, sizeof(link));
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
            {
                scanf("%d", &a);
                if (a)
                    add(i, j);
            }
        int ans = 0;
        for (int i = 1; i <= n; i++)
        {
            memset(vis, 0, sizeof(vis));
            if (find(i))
                ans++;
        }
        if(ans == n)
            printf("Yes\n");
        else
            printf("No\n");
    }
}

[HNOI2012]矿场搭建

Tue, 22 Aug 2017 17:08:30 GMT

题目描述

煤矿工地可以看成是由隧道连接挖煤点组成的无向图。为安全起见，希望在工地发生事故时所有挖煤点的工人都能有一条出路逃到救援出口处。于是矿主决定在某些挖煤点设立救援出口，使得无论哪一个挖煤点坍塌之后，其他挖煤点的工人都有一条道路通向救援出口。请写一个程序，用来计算至少需要设置几个救援出口，以及不同最少救援出口的设置方案总数。

输入输入文件有若干组数据，每组数据的第一行是一个正整数 N（N≤500），表示工地的隧道数，接下来的 N 行每行是用空格隔开的两个整数 S 和 T，表示挖S 与挖煤点 T 由隧道直接连接。输入数据以 0 结尾。

输出

输入文件中有多少组数据，输出文件 output.txt 中就有多少行。每行对应一组输入数据的结果。其中第 i 行以 Case i: 开始（注意大小写，Case 与 i 之间有空格，i 与:之间无空格，: 之后有空格），其后是用空格隔开的两个正整数，第一个正整数表示对于第 i 组输入数据至少需要设置几个救援出口，第二个正整数表示对于第 i 组输入数据不同最少救援出口的设置方案总数。输入数据保证答案小于 2^64。输出格式参照以下输入输出样例。

样例输入

9
1 3
4 1
3 5
1 2
2 6
1 5
6 3
1 6
3 2
6
1 2
1 3
2 4
2 5
3 6
3 7
0

样例输出

Case 1: 2 4
Case 2: 4 1

题解

可也看出如果塌在割点才有影响
所以先跑出所以割点，然后删去割点跑联通块
如果一个块有两个割点那么无所谓。否则建一个方案为点数

最后如果只要一个联通块，那么就要两个点。方案数为n*（n-1）/2

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct edge
{
    int END, next;
} v[10005];
int first[500], p;
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int dfn[500], low[500], Index;
bool iscut[500];
void Tarjan(int x, int fa)
{
    low[x] = dfn[x] = ++Index;
    int S = 0;
    for (int i = first[x]; i != -1; i = v[i].next)
    {
        if (!dfn[v[i].END])
        {
            S++;
            Tarjan(v[i].END, x);
            low[x] = min(low[v[i].END], low[x]);
            if (low[v[i].END] >= dfn[x])
                iscut[x] = 1;
        }
        else
            low[x] = min(low[x], dfn[v[i].END]);
    }
    if (fa < 0 && S == 1)
        iscut[x] = 0;
}
bool vis[500];
int T, size, num;
int color[500];
void dfs(int x)
{
    vis[x] = 1;
    size++;
    for (int i = first[x]; i != -1; i = v[i].next)
    {
        if (!vis[v[i].END])
        {
            if (!iscut[v[i].END])
                dfs(v[i].END);
            else
            {
                if (color[v[i].END] != T)
                    color[v[i].END] = T, num++;
            }
        }
    }
}
int main()
{
    //freopen("bzoj_2730.in","r",stdin);
    //freopen("bzoj_2730.out","w",stdout);
    int P1 = 0;
    while (1)
    {
        memset(vis, 0, sizeof(vis));
        memset(dfn, 0, sizeof(dfn));
        memset(low, 0, sizeof(low));
        memset(iscut, 0, sizeof(iscut));
        memset(first, -1, sizeof(first));
        memset(color, 0, sizeof(color));
        p = 0;
        Index = 0;
        P1++;
        int n = 0, a, b, m;
        scanf("%d", &m);
        if (m == 0)
            break;
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d", &a, &b);
            n = max(a, n);
            n = max(b, n);
            add(a, b);
            add(b, a);
        }
        for (int i = 1; i <= n; i++)
            if (!dfn[i])
                Tarjan(i, -1);
        int ans1 = 0;
        long long ans2 = 1;
        T = 0;
        for (int i = 1; i <= n; i++)
        {
            if (!vis[i] && !iscut[i])
            {
                T++, size = 0, num = 0;
                dfs(i);
                if (num == 1)
                    ans1++, ans2 *= size;
            }
        }
        if (T == 1)
            ans1 = 2, ans2 = n * (n - 1) / 2;
        printf("Case %d: %d %lld\n", P1, ans1, ans2);
    }
}

[NOI2014]魔法森林

Tue, 22 Aug 2017 16:59:12 GMT

题目描述

为了得到书法大家的真传，小E同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含个N节点M条边的无向图，节点标号为1..N，边标号为1..M。初始时小E同学在号节点1，隐士则住在号节点N。小E需要通过这一片魔法森林，才能够拜访到隐士。  魔法森林中居住了一些妖怪。每当有人经过一条边的时候，这条边上的妖怪就会对其发起攻击。幸运的是，在号节点住着两种守护精灵：A型守护精灵与B型守护精灵。小E可以借助它们的力量，达到自己的目的。

只要小E带上足够多的守护精灵，妖怪们就不会发起攻击了。具体来说，无向图中的每一条边Ei包含两个权值Ai与Bi。若身上携带的A型守护精灵个数不少于Ai，且B型守护精灵个数不少于Bi，这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小E发起攻击，他才能成功找到隐士。

由于携带守护精灵是一件非常麻烦的事，小E想要知道，要能够成功拜访到隐士，最少需要携带守护精灵的总个数。守护精灵的总个数为A型守护精灵的个数与B型守护精灵的个数之和。

输入

第1行包含两个整数N,M，表示无向图共有N个节点，M条边。接下来M行，第行包含4个正整数Xi,Yi,Ai,Bi，描述第i条无向边。其中Xi与Yi为该边两个端点的标号，Ai与Bi的含义如题所述。注意数据中可能包含重边与自环。

输出

输出一行一个整数：如果小E可以成功拜访到隐士，输出小E最少需要携带的守护精灵的总个数；如果无论如何小E都无法拜访到隐士，输出“-1”（不含引号）。

样例输入

【输入样例1】
4 5
1 2 19 1
2 3 8 12
2 4 12 15
1 3 17 8
3 4 1 17
【输入样例2】
3 1
1 2 1 1

样例输出

【输出样例1】
32
【样例说明1】
如果小E走路径1→2→4，需要携带19+15=34个守护精灵；
如果小E走路径1→3→4，需要携带17+17=34个守护精灵；
如果小E走路径1→2→3→4，需要携带19+17=36个守护精灵；
如果小E走路径1→3→2→4，需要携带17+15=32个守护精灵。
综上所述，小E最少需要携带32个守护精灵。
【输出样例2】
-1
【样例说明2】
小E无法从1号节点到达3号节点，故输出-1。

题解

对一个权值排序
从小到大逐渐加边维护答案

#include <cstring>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
struct data
{
    int s, e, a, b;
    bool operator<(const data &c) const
    {
        return a < c.a;
    }
} a[100005];
struct edge
{
    int END, v, next;
} v[200005];
int first[50005], p;
void add(int s, int e, int c)
{
    v[p].END = e;
    v[p].v = c;
    v[p].next = first[s];
    first[s] = p++;
}
bool flag[50005];
queue<int> Q;
int dis[50005];
void spfa()
{
    while (!Q.empty())
    {
        int k = Q.front();
        Q.pop();
        flag[k] = 0;
        for (int i = first[k]; i != -1; i = v[i].next)
        {
            if (dis[v[i].END] > max(dis[k], v[i].v))
            {
                dis[v[i].END] = max(dis[k], v[i].v);
                if (!flag[v[i].END])
                {
                    flag[v[i].END] = 1;
                    Q.push(v[i].END);
                }
            }
        }
    }
}
int main()
{
    memset(first, -1, sizeof(first));
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d%d", &a[i].s, &a[i].e, &a[i].a, &a[i].b);
    }
    sort(a + 1, a + m + 1);
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    int ans = 0x3f3f3f3f;
    for (int i = 1; i <= m; i++)
    {
        add(a[i].s, a[i].e, a[i].b);
        add(a[i].e, a[i].s, a[i].b);
        if (!flag[a[i].s])
        {
            Q.push(a[i].s);
            flag[a[i].s] = 1;
        }
        if (!flag[a[i].e])
        {
            Q.push(a[i].e);
            flag[a[i].e] = 1;
        }
        if (a[i + 1].a != a[i].a)
            spfa();
        ans = min(ans, a[i].a + dis[n]);
    }
    if (ans == 0x3f3f3f3f)
        puts("-1");
    else
        printf("%d\n",ans);
}

生日有感

Mon, 21 Aug 2017 15:44:30 GMT

生日有感

其实这是我在这个学校过的第二个生日了，只有两句祝福，但也让我很是高兴。

心中略有一丝伤感但更多的是希望，
我只希望：
下一次，就下一次，我的生日，能在家过。

感谢亲爱的爸爸妈妈和关心我的同学们。

约会

Tue, 15 Aug 2017 20:41:52 GMT

题目描述

输入输出

样例输入

4
1 2
1 3
2 4
1
2 3

样例输出

1

提示

题解

先建出树来，顺便求出每个节点所在子树的size

然后对于每一个询问我们先跑LCA
然后通过树上倍增求出他们的中点
如果他是LCA那么ans = n - size(有起点的儿子) - size(有终点的儿子)
否则 ans = size（mid） - size（有起点的儿子） - size（有终点的儿子）

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct edge
{
    int END, next;
} v[200005];
int first[100005], p, n;
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int size[100005];
int f[100005][30];
int dep[100005];
void dfs(int rt, int fa, int dp)
{
    dep[rt] = dp;
    f[rt][0] = fa;
    for (int i = 1; i <= 20; i++)
        f[rt][i] = f[f[rt][i - 1]][i - 1];
    size[rt] = 1;
    for (int i = first[rt]; i != -1; i = v[i].next)
        if (v[i].END != fa)
        {
            dfs(v[i].END, rt, dp + 1);
            size[rt] += size[v[i].END];
        }
}
int LCA(int a, int b)
{
    if (dep[a] < dep[b])
        swap(a, b);
    int t = dep[a] - dep[b];
    for (int i = 20; i >= 0; i--)
        if (t & (1 << i))
            a = f[a][i];
    if (a == b)
        return a;
    for (int i = 20; i >= 0; i--)
        if (f[a][i] != f[b][i])
            a = f[a][i], b = f[b][i];
    return f[a][0];
}
int Query(int a, int b)
{
    if (a == b)
        return n;
    if (dep[a] < dep[b])
        swap(a, b);
    int Lca = LCA(a, b);
    int l = dep[a] - dep[Lca];
    int r = dep[b] - dep[Lca];
    if ((l + r) & 1)
        return 0;
    int mid = l + r >> 1;
    int k = a;
    for (int i = 20; i >= 0; i--)
        if (mid & (1 << i))
            k = f[k][i];
    if (k == Lca)
    {
        int t = dep[a] - dep[Lca] - 1;
        for (int i = 20; i >= 0; i--)
            if (t & (1 << i))
                a = f[a][i], b = f[b][i];
        return n - size[a] - size[b];
    }
    else
    {
        int t = dep[a] - dep[k] - 1;
        for (int i = 20; i >= 0; i--)
            if (t & (1 << i))
                a = f[a][i];
        return size[k] - size[a];
    }
}
int main(int argc, char const *argv[])
{
    memset(first,-1,sizeof(first));
    int a, b;
    scanf("%d", &n);
    for (int i = 1; i < n; i++)
    {
        scanf("%d%d", &a, &b);
        add(a, b);
        add(b, a);
    }
    dfs(1, 0, 0);
    int m;
    scanf("%d",&m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &a, &b);
        printf("%d\n", Query(a, b));
    }
    return 0;
}

中值滤波

Tue, 15 Aug 2017 20:35:36 GMT

题目描述

输入输出

样例输入

3
0 1 0

样例输出

1
0 0 0

提示

题解

先打表

会发现规律然后我们按照规律模拟就可以了

具体的可以看代码

#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int a[500005], b[500005];
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    a[n+1]=a[n];
    int i = 1, l, r;
    int ans = 0;
    while (i <= n)
    {
        while (i <= n && a[i] == a[i + 1])
        {
            b[i] = a[i];
            i++;
        }
        l = i;
        while (i <= n && a[i] != a[i + 1])
            i++;
        r = i;
        int len = (r - l + 1);
        if (len & 1)
            for (int j = l; j <= r; j++)
                b[j] = a[l];
        else
            for (int j = 1; j * 2 <= len; j++)
                b[l + j - 1] = a[l], b[r - j + 1] = a[r];
        ans = max(ans, (len - 1) / 2);
    }
    printf("%d\n", ans);
    for (int i = 1; i <= n; i++)
        printf("%d ", b[i]);
    //while(1);
}

最长上升子串

Tue, 15 Aug 2017 20:31:52 GMT

题目描述

输入

6
7 2 3 1 5 6

输出

5

题解

直接DP就可以了
很水了
打的有点傻

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int f[300005][2][2], a[300005];
bool change[300005];
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", a + i);
    a[0] = -1;
    int ans = 0;
    f[1][0][0] = 1;
    f[1][0][1] = 0;
    f[1][1][1] = 1;
    f[1][1][0] = 0;
    for (int i = 2; i <= n; i++)
    {
        f[i][0][0] = 1;
        f[i][0][1] = 1;
        f[i][1][1] = 1;
        f[i][1][0] = 0;
        if (a[i] > a[i - 1])
        {
            f[i][0][0] = f[i - 1][0][0] + 1;
            f[i][0][1] = f[i - 1][0][1] + 1;
        }
        if (f[i - 1][1][1] == f[i - 2][0][0] + 1)
        {
            if(a[i] > a[i - 2] + 1)
            {
                f[i][0][1] = max(f[i][0][1], f[i - 1][1][1] + 1);
            }
        }
        else
        {
            f[i][0][1] = max(f[i][0][1], f[i - 1][1][1]);
        }
        f[i][1][1] = max(f[i][1][1], f[i - 1][0][0] + 1);
        ans = max(ans,max(f[i][0][0],max(f[i][0][1],f[i][1][1])));
    }
    printf("%d",ans);
}

便

Tue, 15 Aug 2017 20:15:35 GMT

题目描述

给出一个R*C的棋盘.共有R行C列,R*C个格子.现要在每个格子都填一个非负整数.使得任意一个2*2的正方形区域都满足这样的性质:左上角的数字+右下角的数字=左下角的数字+右上角的数字.有些格子已经确定,你不能更改其中的数字.其他格子的数字由你决定. 这是一个符合要求的3*3的棋盘:


1	2	3
2	3	4
4	5	6

不难验证每个2*2的区域都是符合要求的. Orbitingflea想要知道一个可行的填充棋盘的方案.但是这个方案可能很大.所以你只需对给定的棋盘判定是否存在至少一种可行的填充棋盘的方案.

输入

第一行输入一个T，表示数据组数。接下来T组数据。

每组数据的第1行2个整数R,C表示棋盘的大小.

第2行1个整数n表示已经被填好数字的格子的数目.

接下来n行每行3个整数ri,ci,ai,表示第ri行ci列的格子被填上了数字ai.

输出

T行.第i行是第i组数据的答案.有合法方案时输出一行Yes,没有时输出一行No.

样例输入

6
2 2 3
1 1 0
1 2 10
2 1 20
2 3 5
1 1 0
1 2 10
1 3 20
2 1 30
2 3 40
2 2 3
1 1 20
1 2 10
2 1 0
3 3 4
1 1 0
1 3 10
3 1 10
3 3 20
2 2 4
1 1 0
1 2 10
2 1 30
2 2 20
1 1 1
1 1 -1

样例输出

Yes
No
No
Yes
No
No

题解

每一列差分后得到的结果相同.每一行差分后的结果也相同.于是我们对行列分别用带权并查集维护行之间,列之间的差分关系.如果差分关系出现矛盾(两行之间的差值可以推导出两种可能)则无解.如果差分关系没有矛盾,则需要求出整个矩阵中能推导出的最小值判断是否小于0.

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int fa1[1000005], fa2[1000005];
long long w1[1000005], w2[1000005];
long long Min1[1000005], Min2[1000005];
struct Point
{
    int x, y, v;
} a[1000005];
bool cmpx(const Point &A, const Point &B)
{
    return A.x < B.x;
}
bool cmpy(const Point &A, const Point &B)
{
    return A.y < B.y;
}
int find1(int x)
{
    if (x == fa1[x])
        return x;
    int rt = find1(fa1[x]);
    w1[x] += w1[fa1[x]];
    return fa1[x] = rt;
}
int find2(int x)
{
    if (x == fa2[x])
        return x;
    int rt = find2(fa2[x]);
    w2[x] += w2[fa2[x]];
    return fa2[x] = rt;
}
bool link1(int a, int b, int w)
{
    if (find1(a) != find1(b))
    {
        int fa = find1(a), fb = find1(b);
        fa1[fa] = fa1[fb];
        w1[fa] = w + w1[b] - w1[a];
        return 1;
    }
    else
        return w1[a] == w + w1[b];
}
bool link2(int a, int b, int w)
{
    if (find2(a) != find2(b))
    {
        int fa = find2(a), fb = find2(b);
        fa2[fa] = fa2[fb];
        w2[fa] = w + w2[b] - w2[a];
        return 1;
    }
    else
        return w2[a] == w + w2[b];
}
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        bool flag = 1;
        int R, C;
        scanf("%d%d", &R, &C);
        for (int i = 1; i <= R; i++)
        {
            fa1[i] = i;
            w1[i] = 0;
        }
        for (int i = 1; i <= C; i++)
        {
            fa2[i] = i;
            w2[i] = 0;
        }
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].v);
        for (int i = 1; i <= n; i++)
            if (a[i].v < 0)
                flag = 0;
        sort(a + 1, a + n + 1, cmpx);
        for (int i = 1; i < n; i++)
            if (a[i].x == a[i + 1].x)
                if (!link2(a[i].y, a[i + 1].y, a[i + 1].v - a[i].v))
                    flag = false;
 
        sort(a + 1, a + n + 1, cmpy);
        for (int i = 1; i < n; i++)
            if (a[i].y == a[i + 1].y)
                if (!link1(a[i].x, a[i + 1].x, a[i + 1].v - a[i].v))
                    flag = false;
 
        memset(Min1, 0x3f, sizeof(Min1));
        memset(Min2, 0x3f, sizeof(Min2));
        for (int i = 1; i <= n; i++)
        {
            int rt = find1(a[i].x);
            Min1[rt] = min(Min1[rt], a[i].v + w1[a[i].x]);
        }
        for (int i = 1; i <= R; i++)
        {
            int rt = find1(i);
            Min2[rt] = min(Min2[rt], -w1[i]);
        }
        for (int i = 1; i <= R; i++)
        {
            if (fa1[i] == i && Min1[i] + Min2[i] < 0)
                flag = 0;
        }
        if(flag)
            puts("Yes");
        else
            puts("No");
    }
}

[Haoi2016]字符合并

Tue, 15 Aug 2017 20:14:12 GMT

题目描述

有一个长度为 n 的 01 串，你可以每次将相邻的 k 个字符合并，得到一个新的字符并获得一定分数。得到的新字符和分数由这 k 个字符确定。你需要求出你能获得的最大分数。

输入

第一行两个整数n，k。接下来一行长度为n的01串，表示初始串。接下来2k行，每行一个字符ci和一个整数wi，ci 表示长度为k的01串连成二进制后按从小到大顺序得到的第i种合并方案得到的新字符,wi表示对应的第i种方案对应获得的分数。1<=n<=300,0<=ci<=1,wi>=1,k<=8

输出

输出一个整数表示答案

样例输入

3 2
101
1 10
1 10
0 20
1 30

样例输出

40

//第3行到第6行表示长度为2的4种01串合并方案。00->1,得10分，01->1得10分，10->0得20分，11->1得30分。

题解

令f[i][j][S]表示将i~j这一段消到S这个状态能获得的最大得分。
f[i][j][S<<1]=max(f[i][j][S<<1],f[i][m−1][S]+f[m][j][0])
f[i][j][S<<1|1]=max(f[i][j][S<<1|1],f[i][m−1][S]+f[m][j][1])

#include <cstdio>
#include <cstring>
#include <bitset>
using namespace std;
int a[400], c;
int s[1 << 8];
long long w[1 << 8], f[305][305][1 << 8], INF, ans;
int main()
{
    // freopen("merge.in","r",stdin);
    // freopen("merge.out","w",stdout);
    int n, k;
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
        scanf("%1d", &a[i]);
    for (int i = 0; i < (1 << k); i++)
        scanf("%d%lld", &s[i], &w[i]);
    memset(f, 0x80, sizeof(f));
    memset(&INF, 0x80, sizeof(INF));
    for (int i = 1; i <= n; i++)
        f[i][i][a[i]] = 0;
    for (int l = 2; l <= n; l++)
    {
        for (int i = 1; i <= n - l + 1; i++)
        {
            int j = i + l - 1;
            int len = j - i;
            while (len >= k)
                len -= k - 1;
            for (int m = j; m > i; m -= k - 1)
            {
                for (int S = 0; S < (1 << len); S++)
                {
                    if (f[i][m - 1][S] != INF)
                    {
                        if (f[m][j][0] != INF)
                            f[i][j][S << 1] = max(f[i][j][S << 1], f[i][m - 1][S] + f[m][j][0]);
                        if (f[m][j][1] != INF)
                            f[i][j][S << 1 | 1] = max(f[i][j][S << 1 | 1], f[i][m - 1][S] + f[m][j][1]);
                    }
                }
            }
            if (len == k - 1)
            {
                long long g[2];
                g[0] = g[1] = INF;
                for (int S = 0; S < (1 << k); S++)
                    if (f[i][j][S] != INF)
                        g[s[S]] = max(g[s[S]], f[i][j][S] + w[S]);
                f[i][j][0] = g[0];
                f[i][j][1] = g[1];
            }
        }
    }
    for (int i = 0; i < (1 << k); i++)
        ans = max(ans, f[1][n][i]);
    printf("%lld\n", ans);
    //while(1);
}

从N方到NlogN的转变——FFT

Mon, 14 Aug 2017 21:24:58 GMT

1.Why

为什么我们信息学竞赛要用到FFT
因为我们要优化卷积啊
将n边为log是一个非常大的优化啊

What

什么是FFT呢在wiki上是这么说的

快速傅里叶变换（英语：Fast Fourier Transform, FFT），是计算序列的离散傅里叶变换（DFT）或其逆变换的一种算法。傅里叶分析将信号从原始域（通常是时间或空间）转换到频域的表示或者逆过来转换。FFT会通过把DFT矩阵分解为稀疏（大多为零）因子之积来快速计算此类变换。[1] 因此，它能够将计算DFT的复杂度从只用DFT定义计算需要的 $O(n^{2})$，降低到 $O(n\log n)$，其中 n 为数据大小。

啥你说啥我听不懂（黑人问号?）

如果简单的说就是求两个多项式的乘积

How

其实关于FFT的具体理论很复杂，我一篇博客肯定不能接受清楚所以请有兴趣的人移步Google 或 baidu

如果简单来说FFT用的分制的方法
所以才能有log啊

将一个多项式按奇偶分开
但如果我们直接找值去计算时间复杂度还是$O(n^2)$的

所以出现了一个特殊的东西他叫做n次单位根

然后利用他的性质就可以搞了

先贴两个板子

UOJ 34 多项式乘法

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 1 << 18 | 5;
namespace FFT
{
const double pi = acos(-1.0);
struct Complex
{
    double x, y;
    Complex operator+(const Complex &a)
    {
        return (Complex){x + a.x, y + a.y};
    }
    Complex operator-(const Complex &a)
    {
        return (Complex){x - a.x, y - a.y};
    }
    Complex operator*(const Complex &a)
    {
        return (Complex){x * a.x - y * a.y, x * a.y + y * a.x};
    }
    Complex operator*(const double &a)
    {
        return (Complex){x * a, y * a};
    }
    Complex Get()
    {
        return (Complex){x, -y};
    }
} c[maxn], c1[maxn], V = (Complex){0.5, 0} * (Complex){0, -0.5};
int rev[maxn], N, FU;
double Inv;
void FFt(Complex *a, int op)
{
    Complex w, wn, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = (Complex){cos(op * 2 * pi / k), sin(op * 2 * pi / k)};
        for (int j = 0; j < N; j += k)
        {
            w = (Complex){1, 0};
            for (int i = 0; i < (k >> 1); i++, w = w * wn)
            {
                t = a[i + j + (k >> 1)] * w;
                a[i + j + (k >> 1)] = a[i + j] - t;
                a[i + j] = a[i + j] + t;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = a[i] * Inv;
}
void FFt(int *a, int *b, int *res, int n)
{
    int j;
    N = 1;
    while (N < n)
        N <<= 1;
    FU = N - 1;
    Inv = 1. / N;
    for (int i = 0; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    for (int i = 0; i < N; i++)
        c[i].x = a[i], c[i].y = b[i];
    FFt(c, 1);
    for (int i = 0; i < N; i++)
        j = (N - i) & FU, c1[i] = (c[i] + c[j].Get()) * (c[i] - c[j].Get()) * V;
    FFt(c1, -1);
    for (int i = 0; i < N; i++)
        res[i] = round(c1[i].x);
}
} // FFT

int main(int argc, char const *argv[])
{
    static int a[maxn],b[maxn];
    int n1, n2, m;
    scanf("%d%d", &n1, &n2);
    m = n1 + n2 + 1;
    for (int i = 0; i <= n1; i++)
        scanf("%d", &a[i]);
    for (int i = 0; i <= n2; i++)
        scanf("%d", &b[i]);
    FFT::FFt(a, b, a, m);
    for (int i = 0; i < m; i++)
        printf("%d ", a[i]);
    return 0;
}

COGS 1473. 很强的乘法问题

#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
const double pi = acos(-1.);
struct Complex
{
    double x, y;
    Complex() { ; }
    Complex(double a, double b) : x(a), y(b) {}
    Complex operator+(const Complex &a) { return Complex(x + a.x, y + a.y); }
    Complex operator-(const Complex &a) { return Complex(x - a.x, y - a.y); }
    Complex operator*(const Complex &a) { return Complex(x * a.x - y * a.y, x * a.y + y * a.x); }
    Complex operator*(const double a) { return Complex(x * a, y * a); }
    Complex Get() { return Complex(x, -y); }
} A[150005 << 3], B[150005 << 3];
int rev[150005 << 3], N, FU;
double INV;
void FFt(Complex *a, int op)
{
    Complex w, wn, t;
    for (int i = 0; i < N; i++)
        if (i < rev[i])
            std::swap(a[i], a[rev[i]]);
    for (int k = 2; k <= N; k <<= 1)
    {
        wn = Complex(cos(op * 2 * pi / k), sin(op * 2 * pi / k));
        for (int j = 0; j < N; j += k)
        {
            w = Complex(1, 0);
            for (int i = 0; i < (k >> 1); i++, w = w * wn)
            {
                t = a[i + j + (k >> 1)] * w;
                a[i + j + (k >> 1)] = a[i + j] - t;
                a[i + j] = a[i + j] + t;
            }
        }
    }
    if (op == -1)
        for (int i = 0; i < N; i++)
            a[i] = a[i] * INV;
}
void FFt(const int *a, const int *b, int *res, int n)
{
    N = 1;
    while (N < n)
        N <<= 1;
    INV = 1. / N;
    for (int i = 0; i < N; i++)
        if (i & 1)
            rev[i] = (rev[i >> 1] >> 1) | (N >> 1);
        else
            rev[i] = (rev[i >> 1] >> 1);
    for (int i = 0; i < N; i++)
        A[i].x = a[i], B[i].x = b[i];
    FFt(A, 1), FFt(B, 1);
    for (int i = 0; i < N; i++)
        A[i] = A[i] * B[i];
    FFt(A, -1);
    for (int i = 0; i < N; i++)
        res[i] = round(A[i].x);
}
char s[150005 << 2];
struct BigNum
{
    int len;
    int a[1000005];
    void read()
    {
        scanf("%s", s);
        len = strlen(s);
        for (int i = len - 1, j = 0; i >= 0; i--, j++)
            a[j] = s[i] - '0';
    }
    BigNum operator*(const BigNum &b)
    {
        BigNum ans;
        ans.len = len + b.len - 1;
        FFt(a, b.a, ans.a, ans.len + 1);
        for (int i = 0; i <= ans.len + 2; i++)
        {
            if (ans.a[i] > 9)
            {
                ans.a[i + 1] += ans.a[i] / 10;
                ans.a[i] %= 10;
            }
        }
        while (ans.a[ans.len])
            ans.len++;
        return ans;
    }
    void print()
    {
        for (int i = len - 1; i >= 0; i--)
            printf("%d", a[i]);
        printf("\n");
    }
} a, b;
 
int main()
{
    freopen("bettermul.in","r",stdin);
    freopen("bettermul.out","w",stdout);
    a.read();
    b.read();
    (a * b).print();
    //while (1)
        ;
}

BZOJ 3529 [Sdoi2014] 数表

Mon, 14 Aug 2017 21:19:20 GMT

Description

有一张N×m的数表，其第i行第j列（1 < =i < =N，1 < =j < =m）的数值为能同时整除i和j的所有自然数之和。给定a，计算数表中不大于a的数之和。

Input

输入包含多组数据。输入的第一行一个整数Q表示测试点内的数据组数，接下来Q行，每行三个整数n，m，a(|a| < =10^9)描述一组数据。

Output

对每组数据，输出一行一个整数，表示答案模2^31的值。

Sample Input

2
4 4 3
10 10 5

Sample Output

20
148

HINT

1 < =N．m < =10^5 ，1 < =Q <=2×10^4

题解

先推试子

先不考虑a

设$F(i)$为i的约数和
设$g(i)=\sum_{i|d}{\mu(\frac{d}{i})\lfloor \frac{n}{d} \rfloor \lfloor \frac{m}{d} \rfloor}$
可以轻松的得
$$ \sum_{i=1}^{n}{F(i)g(i)} = \sum_{d=1}^{n}{\lfloor \frac{n}{d} \rfloor \lfloor \frac{m}{d} \rfloor \sum_{i|d}{F(i)\mu(\frac{d}{i})}} $$

对于$\sum_{i|d}{F(i)\mu(\frac{d}{i})}$想怎么求就怎么求

而如果有a
那么我们可以离线，树状数组维护就可以

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
using namespace std;
unsigned int tmp1[100005], tmp2[100005], s[100005];
int prime[100005], tot;
int mu[100005];
bool isnprime[100005];
int a[100005];
int N = 100000;
int comp(const int &c, const int &b)
{
    return s[c] < s[b];
}
void Get_Fun()
{
    s[1] = mu[1] = 1;
    tmp1[1] = tmp2[1] = 0;
    for (int i = 2; i <= N; i++)
    {
        if (!isnprime[i])
        {
            prime[++tot] = i;
            mu[i] = -1;
            tmp1[i] = i + 1, tmp2[i] = i;
            s[i] = i + 1;
        }
        for (int j = 1; j <= tot; j++)
        {
            if (i * prime[j] > N)
                break;
            isnprime[i * prime[j]] = 1;
            if (i % prime[j] == 0)
            {
                mu[i * prime[j]] = 0;
                s[i * prime[j]] = s[i] / tmp1[i] * (tmp1[i] + tmp2[i] * prime[j]);
                tmp1[i * prime[j]] = tmp1[i] + tmp2[i] * prime[j];
                tmp2[i * prime[j]] = tmp2[i] * prime[j];
                break;
            }
            mu[i*prime[j]] = -mu[i];
            s[i * prime[j]] = s[i] * s[prime[j]];
            tmp1[i * prime[j]] = prime[j] + 1;
            tmp2[i * prime[j]] = prime[j];
        }
    }
    for (int i = 1; i <= N; i++)
        a[i] = i;
    sort(a + 1, a + N + 1, comp);
}
unsigned int Sum[100005];
#define lowbit(_) ((_) & (-_))
void add(int a, int b)
{
    for (int i = a; i <= N; i += lowbit(i))
        Sum[i] += b;
}
unsigned int Query(int a)
{
    unsigned int ans = 0;
    for (int i = a; i > 0; i -= lowbit(i))
        ans += Sum[i];
    return ans;
}
struct data
{
    int n, m, a, ID;
    bool operator<(const data &b) const
    {
        return a < b.a;
    }
} Q[20005];
unsigned int ans[20005];
unsigned int Query(data S)
{
    if (S.n > S.m)
        swap(S.n, S.m);
    unsigned int ans = 0,last;
    for (int i = 1; i <= S.n; i = last + 1)
    {
        last = min(S.n / (S.n / i), S.m / (S.m / i));
        ans += (Query(last) - Query(i - 1)) * (S.n / i) * (S.m / i);
    }
    return ans;
}
int main(int argc, char const *argv[])
{
    freopen("sdoi2014shb.in","r",stdin);
    freopen("sdoi2014shb.out","w",stdout);
    int T;
    Get_Fun();
    scanf("%d", &T);
    for (int i = 1; i <= T; i++)
        scanf("%d%d%d", &Q[i].n, &Q[i].m, &Q[i].a), Q[i].ID = i;
    sort(Q + 1, Q + T + 1);
    for (int i = 1, j = 1; i <= T; i++)
    {
        while (s[a[j]] <= Q[i].a && j <= N)
        {
            for (int k = 1; k * a[j] <= N; k++)
                add(k * a[j], s[a[j]] * mu[k]);
            j++;
        }
        ans[Q[i].ID] = Query(Q[i]);
    }
    for (int i = 1; i <= T; i++)
    {
        printf("%d\n",((ans[i]<<1)>>1));
    }
    return 0;
}

BZOJ 4407 于神之怒加强版

Sun, 13 Aug 2017 21:11:37 GMT

【题目描述】

给定n,m,k,计算 $\sum_{i=1}^{n}{\sum_{j=1}^{m}{gcd(i,j)^k}}$ 对1000000007取模的结果

【输入格式】

多组数据。第一行是两个数T,K; 之后的T行，每行两个整数n，m；

【输出格式】

K行，每行一个结果

【样例输入】

1 2
3 3

【样例输出】

20

【提示】

T<=2000,1<=N,M,K<=5000000

题解

第一步推式子

$\sum_{i=1}^{n}{\sum_{j=1}^{m}{gcd(i,j)^k}}$
$=\sum_{d=1}^{n}{d^k\sum_{i=1}^{n}{\sum_{j=1}^{m}{[gcd(i,j)==d]}}}$
$=\sum_{d=1}^{n}{d^k\sum_{i=1}^{\lfloor \frac{n}{d} \rfloor}{\sum_{j=1}^{\lfloor \frac{m}{d} \rfloor}{[gcd(i,j)==1]}}}$
$=\sum_{d=1}^{n}{d^k\sum_{i=1}^{\lfloor \frac{n}{d} \rfloor}{\sum_{j=1}^{\lfloor \frac{m}{d} \rfloor}{\sum_{c|i,c|j}{\mu{c}}}}}$
另$T = dc$
$=\sum_{T=1}^{n}{\sum_{d|T}{d^k \mu{\frac{T}{d}} \lfloor \frac{n}{T} \rfloor \lfloor \frac{m}{T} \rfloor}}$
$=\sum_{T=1}^{n}{\lfloor \frac{n}{T} \rfloor \lfloor \frac{m}{T} \rfloor \sum_{d|T}{d^k \mu{\frac{T}{d}}}}$

然后我们需要线性筛出$\sum_{d|T}{d^k \mu{\frac{T}{d}}}$就可以了
设$g(T) = \sum_{d|T}{d^k \mu{\frac{T}{d}}}$
显然是积性函数别问我怎么知道的
当互质时 $g(TP) = g(T) * g(p)$
当不互质时又要推狮子
根据$\mu$函数的定义
当且仅当不含平方因子时不为零
所以质因子只有选和不选两种状态，有用的状态数是不变的
每一个有用的$\mu$ 都乘了一个p^k; 所以$ g(Tp) = g(T) * p^k $

#define LL long long
 
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int prime[500005], tot;
const int MOD = 1000000007;
bool isnprime[5000005];
LL g[5000005];
LL primeK[500005], n, k, m;
LL N = 5000000;
LL pow_mod(LL a, LL b)
{
    LL ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}
void Get_g()
{
    g[1] = 1;
    for (int i = 2; i <= N; i++)
    {
        if (!isnprime[i])
        {
            prime[++tot] = i;
            g[i] = (primeK[tot] = pow_mod(i, k)) - 1;
        }
        for (int j = 1; j <= tot; j++)
        {
            if (i * prime[j] > N)
                break;
            isnprime[i * prime[j]] = 1;
            if (i % prime[j] == 0)
            {
                g[i * prime[j]] = g[i] * primeK[j] % MOD;
                break;
            }
            g[i * prime[j]] = g[i] * g[prime[j]] % MOD;
        }
    }
    for (int i = 2; i <= N; i++)
        g[i] += g[i - 1], g[i] %= MOD;
}
int main()
{
    freopen("bzoj_4407.in","r",stdin);
    freopen("bzoj_4407.out","w",stdout);
    int t;
    scanf("%d%lld", &t, &k);
    Get_g();
    while (t--)
    {
        scanf("%lld%lld", &n, &m);
        int last;
        LL ret = 0;
        if (n > m)
            swap(n, m);
        for (int i = 1; i <= n; i = last + 1)
        {
            last = min(n / (n / i), m / (m / i));
            (ret += (n / i) * (m / i) % MOD * (g[last] - g[i - 1] + MOD) % MOD)%=MOD;
        }
        printf("%lld\n", ret);
    }
}

BZOJ 4173 数学

Sun, 13 Aug 2017 06:13:24 GMT

Description

Input

输入文件的第一行输入两个正整数。

Output

如题

Sample Input

5 6

Sample Output

240

HINT

N,M<=10^15

题解

简单来说就是找规律

答案为a*b*phi(a)*phi(b)

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const long long MOD = 998244353;
long long phi(long long x)
{
    double ans = x;
    int i = 2;
    int Sqrt = ceil(sqrt(x));
    while (x != 1)
    {
        if (i > Sqrt)
        {
            ans *= (1 - (double)1 / x);
            break;
        }
        if (x % i == 0)
        {
            ans *= (1 - (double)1 / i);
            while (x % i == 0)
                x /= i;
        }
        i++;
    }
    return (long long)ans;
}
int main()
{
    long long a,b;
    scanf("%lld%lld",&a,&b);
    printf("%lld",((((a%MOD)*(b%MOD)%MOD)*(phi(a)%MOD)%MOD)*(phi(b)%MOD))%MOD);
    //while(1);
}

BZOJ 3505 [Cqoi2014]数三角形

Sat, 12 Aug 2017 21:28:54 GMT

Description

给定一个nxm的网格，请计算三点都在格点上的三角形共有多少个。下图为4x4的网格上的一个三角形。注意三角形的三点不能共线。

Input

输入一行，包含两个空格分隔的正整数m和n。

Output

输出一个正整数，为所求三角形数量。

Sample Input

2 2

Sample Output

76

数据范围

1<=m,n<=1000

题解

先用组合数算出所有的可能

在 Gcd 去掉在一条线上的就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
long long c[1000005][4];
long long gcd(long long a, long long b)
{
    return b == 0 ? a : gcd(b, a % b);
}
int main()
{
    long long n, m;
    scanf("%lld%lld", &n, &m);
    n++, m++;
    c[0][0] = 1;
    for (long long i = 1; i <= n * m; i++)
    {
        c[i][0] = 1;
        for (long long j = 1; j <= 3; j++)
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
    }
    long long ans = c[n * m][3];
    ans -= c[n][3] * m;
    ans -= c[m][3] * n;
    for (long long i = 1; i < n; i++)
    {
        for (long long j = 1; j < m; j++)
        {
            long long Gcd = gcd(i, j);
            if (Gcd > 1)
                ans -= 2 * (Gcd - 1) * (n - i) * (m - j);
        }
    }
    printf("%lld", ans);
}

改造二叉树

Sat, 12 Aug 2017 21:09:24 GMT

输入

3
2 2 2
1 0
1 1

输出

2

题解

先中序遍历
然后按a[i] - i 跑最长不降子序列

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct Tree
{
    int ch[2];
    int v;
} Node[100005];
int a[100005], Ind, val[100005], c[100005];
void dfs(int rt)
{
    if (rt)
    {
        dfs(Node[rt].ch[0]);
        a[++Ind] = Node[rt].v;
        dfs(Node[rt].ch[1]);
    }
}
int f[100005], Max[100005];
int tot;
inline int lowbit(int x) { return x & (-x); }
void Update(int x, int val)
{
    for (int i = x; i <= tot; i += lowbit(i))
        Max[i] = max(Max[i], val);
    return;
}
int Query(int x)
{
    int ans = 0;
    for (int i = x; i; i -= lowbit(i))
        ans = max(ans, Max[i]);
    return ans;
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &Node[i].v);
    }
    int fa, d;
    for (int i = 2; i <= n; i++)
    {
        scanf("%d%d", &fa, &d);
        Node[fa].ch[d] = i;
    }
    dfs(1);
    //memset(f, 0x7f, sizeof(f));
    for (int i = 1; i <= n; i++)
    {
        a[i] = a[i] - i;
        c[i] = a[i];
    }
    int ans = 0;
    sort(a + 1, a + n + 1);
    tot = unique(a + 1, a + n + 1) - a - 1;
    for (int i = 1; i <= n; i++)
    {
        int now = lower_bound(a + 1, a + tot + 1, c[i]) - a;
        f[i] = Query(now) + 1;
        Update(now, f[i]);
        ans = max(ans, f[i]);
    }
    printf("%d", n - ans);
    //while(1);
}

序列

Sat, 12 Aug 2017 20:38:23 GMT

输入

5 3
2 4 2 3 4

输出

39

题解

从比他小的中找
组合数一搞就行

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
const LL P = 1e9 + 7;
LL F[100005];
void Init()
{
    F[0] = 1;
    for (int i = 1; i <= 100000; i++)
        F[i] = i * F[i - 1] % P;
}
LL pow_mod(LL a, int b)
{
    LL ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % P;
        b >>= 1;
        a = a * a % P;
    }
    return ans;
}
LL C(int n, int m)
{
    if (m > n || m < 0)
        return 0;
    return F[n] * pow_mod(F[m] * F[n - m] % P, P - 2) % P;
}
LL a[100005], Has[100005];
int Sum[100005], n;
 
#define lowbit(_) ((_) & (-_))
 
void add(int x, int c)
{
    for (int i = x; i <= n; i += lowbit(i))
        Sum[i] += c;
}
int Query(int x)
{
    int ans = 0;
    for (int i = x; i > 0; i -= lowbit(i))
        ans += Sum[i];
    return ans;
}
int fron[100005], nxt[100005];
int main()
{
    Init();
    int K;
    scanf("%d%d", &n, &K);
    for (int i = 1; i <= n; i++)
    {
        scanf("%lld", &a[i]);
    }
    sort(a + 1, a + n + 1);
    LL ans = 0;
    for (int i = 1; i <= n; i++)
    {
        ans = (ans + a[i] * C(i - 1, K - 1)) % P;
    }
    printf("%lld\n", ans);
}

灌水

Sat, 12 Aug 2017 20:19:27 GMT

输入

样例输入1：
3 1
样例输出1：
3 1 2
样例输入2：
4 1
样例输出2：
4 3 1 2
样例输入3：
8 17
样例输出3：
6 2 3 1 8 4 5 7

提示

题解

先找规律然后瞎搞就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
LL Sum[1000005];
LL x;
int ans[1000005];
int main()
{
    int n;
    scanf("%d%lld", &n, &x);
    for (int i = n - 2; i >= 0; i--)
        Sum[i] = Sum[i + 1] + i;
    if (Sum[0] < x)
    {
        puts("-1");
        return 0;
    }
    int k, i, j;
    for (k = 1; k <= n - 2; k++)
        if (x > Sum[k])
            break;
    x = x - Sum[k];
    for (i = n - k, j = 1; i <= n - 1; i++, j++)
        ans[j] = i;
    for (i = 1; i <= n - k - 1; i++, j++)
        ans[j] = i;
    ans[n] = n;
    i = 1;
    while (x--)
    {
        swap(ans[i], ans[i + 1]);
        i++;
    }
    for (i = 1; i < n; i++)
        printf("%d ", ans[i]);
    printf("%d\n", ans[n]);
}

[JLOI2011]飞行路线

Thu, 10 Aug 2017 21:17:13 GMT

题目描述

Alice和Bob现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在n个城市设有业务，设这些城市分别标记为0到n-1，一共有m种航线，每种航线连接两个城市，并且航线有一定的价格。

Alice和Bob现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多k种航线上搭乘飞机。那么Alice和Bob这次出行最少花费多少？

输入

数据的第一行有三个整数，n,m,k，分别表示城市数，航线数和免费乘坐次数。第二行有两个整数，s,t，分别表示他们出行的起点城市编号和终点城市编号。(0<=s,t<n) 接下来有m行，每行三个整数，a,b,c，表示存在一种航线，能从城市a到达城市b，或从城市b到达城市a，价格为c。(0<=a,b<n,a与b不相等，0<=c<=1000)

输出

只有一行，包含一个整数，为最少花费。

样例输入

5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100

样例输出

8

提示

对于30%的数据,2<=n<=50,1<=m<=300,k=0; 对于50%的数据,2<=n<=600,1<=m<=6000,0<=k<=1; 对于100%的数据,2<=n<=10000,1<=m<=50000,0<=k<=10.

题解

二维SPFA优化一下

#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
struct edge
{
    int END, next, v;
} v[100005];
int first[10005], p;
void add(int a, int b, int c)
{
    v[p].END = b;
    v[p].next = first[a];
    v[p].v = c;
    first[a] = p++;
}
 
int dis[10005][11];
bool flag[10005][11];
int Top;
struct data
{
    int k, tmp;
    bool operator<(const data &a) const
    {
        return dis[k][tmp] > dis[a.k][a.tmp];
    }
};
int Spfa(int S, int T)
{
    memset(dis, 0x3f, sizeof(dis));
    flag[S][0] = 1;
    priority_queue<data> Q;
    Q.push((data){S, 0});
    dis[S][0] = 0;
    while (!Q.empty())
    {
        int k = Q.top().k;
        int tmp = Q.top().tmp;
        flag[k][tmp] = 0;
        Q.pop();
        for (int i = first[k]; i != -1; i = v[i].next)
        {
            if (dis[v[i].END][tmp] > dis[k][tmp] + v[i].v)
            {
                dis[v[i].END][tmp] = dis[k][tmp] + v[i].v;
                if (!flag[v[i].END][tmp])
                {
                    flag[v[i].END][tmp] = 1;
                    Q.push((data){v[i].END, tmp});
                }
            }
            if (dis[v[i].END][tmp + 1] > dis[k][tmp] && tmp + 1 <= Top)
            {
                dis[v[i].END][tmp + 1] = dis[k][tmp];
                if (!flag[v[i].END][tmp + 1])
                {
                    flag[v[i].END][tmp + 1] = 1;
                    Q.push((data){v[i].END, tmp + 1});
                }
            }
        }
    }
    int ans = 0x7fffffff;
    for (int i = 0; i <= Top; i++)
        ans = min(ans, dis[T][i]);
    return ans;
}
int main(int argc, char const *argv[])
{
    memset(first, -1, sizeof(first));
    int n, m;
    scanf("%d%d%d", &n, &m, &Top);
    int S, T;
    scanf("%d%d", &S, &T);
    S++, T++;
    int a, b, c;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        add(a + 1, b + 1, c);
        add(b + 1, a + 1, c);
    }
    printf("%d", Spfa(S, T));
    return 0;
}

Function

Thu, 10 Aug 2017 21:16:58 GMT

题解

暴力搞就可以
先预处理出所有范围内的函数值
卡卡常-Owys

直接O(1) 查询就可以了

/**
******************************************************************************
* @file Function
* @author   WildRage
* @version v 1.0
* @date 2017-8-10 10:57:28
* @brief 
******************************************************************************
*/
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
LL a[1005], b[1005], c[1005];
LL Max[200005];
int fix = 100001;
int main()
{
    memset(Max, 0x80, sizeof(Max));
    int n, q;
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++)
    {
        scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
    }
    LL u;
    for (int i = -100000; i <= 100000; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            Max[i + fix] = max(Max[i + fix], a[j] * i * i + b[j] * i + c[j]);
        }
    }
    while (q--)
    {
        scanf("%lld", &u);
        printf("%lld\n", Max[u + fix]);
    }
    return 0;
}

公主的朋友

Thu, 10 Aug 2017 21:08:31 GMT

题目描述

由于 Wulala 在上个问题中的精彩表现，公主认为 Wulala 是一个很棒的人，就把 Wulala 留在了 X 国。这时正好公主的一位传教士朋友来拜访公主，于是想找 wulala 帮忙X 国如同一条直线，其中有 n 个城市,从东向西分别编号为 1~n。而他的国家中有 m 种宗教，每个城市一定会有一种信仰的宗教。  有时候有些城市为了获得更多的认可，会派出信仰本城市宗教的传教士前往其他国家。X 国的传教士都十分厉害，只要是他途经的地方都会改信他所传播的宗教。传教士们在路上碰到自己宗教的城市自然就不用传教了，可以停下来看看里番啥的，所以每一个传教士在旅行前都会计算自己可以在多少城市停下来(不包括起始的城市)。而传教士们都是文科僧，数学是很差的，所以他希望 Wulala 能帮他计算。可 Wulala 数学也不好，但他又不想在公主面前丢脸，你能帮帮他吗？

输入

第一行两个整数 n，m 第二行 n 个整数第 i 个整数代表第 i 各城市信仰的宗教第三行一个整数 T 代表传教士的个数接下来 T 行每行两个整数 x，y 代表 x 城向 y 城派遣了一个传教士(保证 x < y)

输出

输出 T 行，第 i 行代表第 i 个传教士询问的答案

样例输入

2 2
1 2
2
1 2
1 2

样例输出

0
1

提示

对于 30%的数据 n <= 100000, m <= 10, T <= 100 对于 60%的数据 n <= 100000, m <= 10, T <= 100000 对于 100%的数据 n <= 100000, m <= 300, T <= 100000

题解

分块直接维护就可以了
原来分块也可以是正解

/**
******************************************************************************
* @file Wulala
* @author   WildRage
* @version v 0.9
* @date 2017-8-10 10:58:12
* @brief 
******************************************************************************
*/
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100001, M = 301;
int a[N], in[N], n, m;
int Sum[500][305], Change[500];
int block;
int lp[500], rp[500];
int Query(int l, int r)
{
    int L = in[l], R = in[r];
    int ans = 0;
    bool flag = 0;
    if (L == R)
    {
        if (Change[L])
            return r - l;
        for (int i = l + 1; i <= r; i++)
        {
            if (a[i] == a[l])
                ans++;
            a[i] = a[l];
        }
        for (int i = lp[L]; i < l; i++)
            if (a[i] != a[l])
            {
                flag = 1;
                break;
            }
        if (flag == 1)
            return ans;
        for (int i = r + 1; i <= rp[R]; i++)
        {
            if (a[i] != a[l])
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0)
            Change[L] = a[l];
        return ans;
    }
    else
    {
        if (Change[L] == a[l])
            ans += (rp[L] - l);
        else
        {
            flag = 0;
            for (int i = l + 1; i <= rp[L]; i++)
            {
                if (a[i] == a[l])
                    ans++;
                a[i] = a[l];
            }
            for (int i = lp[L]; i < l; i++)
                if (a[i] != a[l])
                {
                    flag = 1;
                    break;
                }
            if (!flag)
                Change[L] = a[l];
        }
        if (Change[R])
        {
            if (Change[R] == a[l])
                ans += (r - lp[R] + 1);
            else
            {
                for (int i = lp[R]; i <= r; i++)
                    a[i] = a[l];
                Change[R] = 0;
            }
        }
        else
        {
            flag = 0;
            for (int i = lp[R]; i <= r; i++)
            {
                if (a[i] == a[l])
                    ans++;
                a[i] = a[l];
            }
            for (int i = r + 1; i <= rp[R]; i++)
                if (a[i] != a[l])
                {
                    flag = 1;
                    break;
                }
            if (!flag)
                Change[R] = a[l];
        }
        for (int i = L + 1; i < R; i++)
        {
            if (Change[i])
            {
                if (Change[i] == a[l])
                    ans += block;
                else
                {
                    for (int j = lp[i]; j <= rp[i]; j++)
                        a[j] = a[l];
                    Change[i] = a[l];
                }
            }
            else
            {
                for(int j = lp[i];j<=rp[i];j++)
                {
                    if(a[j]==a[l])
                        ans++;
                    a[j] = a[l];
                }
                Change[i] = a[l];
            }
        }
        return ans;
    }
}
int main()
{
    int c, b;
    scanf("%d%d", &n, &m);
    block = 316;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        in[i] = (i - 1) / block + 1;
        Sum[in[i]][a[i]]++;
    }
    for (int i = 1; i <= in[n]; i++)
        lp[i] = (i - 1) * block + 1, rp[i] = min(n, i * block);
    int T;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &c, &b);
        int ans = Query(c, b);
        printf("%d\n", ans);
    }
}

Evensgn 剪树枝

Thu, 10 Aug 2017 21:04:03 GMT

题目描述

繁华中学有一棵苹果树。苹果树有 n 个节点（也就是苹果），n − 1 条边（也就是树枝）。调皮的 Evensgn 爬到苹果树上。他发现这棵苹果树上的苹果有两种：一种是黑苹果，一种是红苹果。Evensgn 想要剪掉 k 条树枝，将整棵树分成 k + 1 个部分。他想要保证每个部分里面有且仅有一个黑苹果。请问他一共有多少种剪树枝的方案？

输入

第一行一个数字 n，表示苹果树的节点（苹果）个数。第二行一共 n − 1 个数字 p0, p1, p2, p3, ..., pn−2，pi 表示第 i + 1 个节点和 pi 节点之间有一条边。注意，点的编号是 0 到 n − 1。第三行一共 n 个数字 x0, x1, x2, x3, ..., xn−1。如果 xi 是 1，表示 i 号节点是黑苹果；如果 xi 是 0，表示 i 号节点是红苹果。

输出

输出一个数字，表示总方案数。答案对 109 + 7 取模。

样例输入

样例输入 1
3
0 0
0 1 1
样例输入 2
6
0 1 1 0 4
1 1 0 0 1 0
样例输入 3
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1

样例输出

样例输出 1
2
样例输出 2
1
样例输出 3
27

提示

数据范围对于 30% 的数据，1 ≤ n ≤ 10。对于 60% 的数据，1 ≤ n ≤ 100。对于 80% 的数据，1 ≤ n ≤ 1000。对于 100% 的数据，1 ≤ n ≤ 105。对于所有数据点，都有 0 ≤ pi ≤ n − 1，xi = 0 或 xi = 1。特别地，60% 中、80% 中、100% 中各有一个点，树的形态是一条链。

题解

题解链接Evensgn 剪树枝树规 Ivan

f[x][0]表示与其父边相连的连通块内没有黑苹果的方案数，
f[x][1]则表示有黑苹果，
如果父边被切断，相当于没有黑苹果
初始化时，假设切掉父边，f[x][0]=1,f[x][1]=0;
递归回时转移,每递归回一个子树,f[x][1]=f[x][1]*f[v][0]+f[x][0]*f[v][1],f[x][0]=f[x][0]*f[v][0];
最后处理完每个子树时,若其为黑苹果f[x][1]=f[x][0],否则f[x][0]=f[x][0]+f[x][1]（可以切掉）

Mycode

/**
******************************************************************************
* @file Evensgn
* @author WildRage
* @version v 1.0
* @date  2017-5-10 10:55:23
* @brief 
******************************************************************************
*/
#include <cstdio>
#include <cstring>
#include <vector>
const int P = 1e9 + 7;
namespace Mine_WorkSpace
{
struct data
{
    struct edge
    {
        int END, next;
    } v[200005];
    int first[100005], p;
    data()
    {
        memset(first, -1, sizeof(first));
        p = 0;
    }
    void add(int a, int b)
    {
        v[p].END = b;
        v[p].next = first[a];
        first[a] = p++;
    }
} Edge;
bool color[100005];
long long f[100005][2];
void  DP(int rt, int fa)
{
    f[rt][0] = 1;
    f[rt][1] = 0;
    for (int i = Edge.first[rt]; i != -1; i = Edge.v[i].next)
    {
        if (fa != Edge.v[i].END)
        {
            DP(Edge.v[i].END, rt);
            f[rt][1] = (f[rt][1] * f[Edge.v[i].END][0]) % P;
            f[rt][1] = (f[rt][1] + f[Edge.v[i].END][1] * f[rt][0]) % P;
            f[rt][0] = (f[rt][0] * f[Edge.v[i].END][0]) % P;
        }
    }
    if (color[rt])
        f[rt][1] = f[rt][0];
    else
        f[rt][0] = (f[rt][1] + f[rt][0]) % P;
}
int Main()
{
    int n;
    scanf("%d", &n);
    int a, b;
    for (int i = 1; i < n; i++)
    {
        scanf("%d", &b);
        Edge.add(i + 1, b + 1), Edge.add(b + 1, i + 1);
    }
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a);
        if (a)
            color[i] = 1;
    }
    DP(1,0);
    printf("%lld\n", f[1][1]);
    // Print_tree(1);
    // while(1);
}
}
int main() { Mine_WorkSpace::Main(); }

[NOI2017] 蚯蚓排队

Wed, 09 Aug 2017 21:24:05 GMT

题目描述蚯蚓幼儿园有nnn只蚯蚓。幼儿园园长神刀手为了管理方便，时常让这些蚯蚓们列队表演。  所有蚯蚓用从 1 到 n 的连续正整数编号。每只蚯蚓的长度可以用一个正整数表示，根据入园要求，所有蚯蚓的长度都不超过 6 。神刀手希望这些蚯蚓排成若干个队伍，初始时，每只蚯蚓各自排成一个仅有一只蚯蚓的队伍，该蚯蚓既在队首，也在队尾。

神刀手将会依次进行 m 次操作，每个操作都是以下三种操作中的一种：

给出 i 和 j ，令 i 号蚯蚓与 j 号蚯蚓所在的两个队伍合并为一个队伍，具体来说，令 j 号蚯蚓紧挨在 i 号蚯蚓之后，其余蚯蚓保持队伍的前后关系不变。给出 i ，令 i 号蚯蚓与紧挨其后的一只蚯蚓分离为两个队伍，具体来说，在分离之后， i 号蚯蚓在其中一个队伍的队尾，原本紧挨其后的那一只蚯蚓在另一个队伍的队首，其余蚯蚓保持队伍的前后关系不变。给出一个正整数 k 和一个长度至少为 k 的数字串 s ，对于 s 的每个长度为 k 的连续子串 t （这样的子串共有 ∣s∣−k+1 个，其中 ∣s∣|s|∣s∣ 为 s 的长度），定义函数 f(t) ，询问所有这些f(t)的乘积对 998244353 取模后的结果。其中f(t)的定义如下：对于当前的蚯蚓队伍，定义某个蚯蚓的向后 k 数字串为：从该蚯蚓出发，沿队伍的向后方向，寻找最近的 k 只蚯蚓（包括其自身），将这些蚯蚓的长度视作字符连接而成的数字串；如果这样找到的蚯蚓不足 k 只，则其没有向后k数字串。例如蚯蚓的队伍为 10 号蚯蚓在队首，其后是 22 号蚯蚓，其后是 3 号蚯蚓（为队尾），这些蚯蚓的长度分别为 4 、 5 、 6 ，则 10 号蚯蚓的向后 3 数字串为456， 22 号蚯蚓没有向后 3 数字串，但其向后 2 数字串为56，其向后 1 数字串为5。

而 f(t) 表示所有蚯蚓中，向后 k 数字串恰好为 t 的蚯蚓只数。输入格式从标准输入读入数据。

输入文件的第一行有两个正整数 n,m ，分别表示蚯蚓的只数与操作次数。

第二行包含 n 个不超过 6 的正整数，依次表示编号为 1,2,…,n的蚯蚓的长度。

!!!

不想粘题了

好气

链接LOJ

题解

哈希能过
但要注意一下

每合并一次就相当于增加了50^2种情况
合并和拆分是一样的
然后查询的时候硬跑就可以了

#include <cstdio>
#include <cstring>
using namespace std;
#define LL unsigned long long
const int N = 300010, M = 15000010, L = 20000010;
const LL P = 23333333, p = 1000007, mod = 998244353;
int head[P], next[L], cnt[L], E, Next[N], Pre[N], a[N];
LL w[L], Pow[60];
int n, m;
char str[L];
void Insert(LL x, int y)
{
    LL now = x % P;
    bool flag = 0;
    for (int i = head[now]; i; i = next[i])
        if (w[i] == x)
        {
            cnt[i] += y;
            flag = 1;
            break;
        }
    if (!flag)
    {
        next[++E] = head[now];
        head[now] = E;
        cnt[E] = 1;
        w[E] = x;
    }
}
int Query(LL x)
{
    LL now = x % P;
    for (int i = head[now]; i; i = next[i])
        if (w[i] == x)
            return cnt[i];
    return 0;
}
void Change(int x, int y)
{
    int now = x;
    for (int k = 1; k <= 50; k++)
    {
        int ret = now;
        LL Hash = a[now];
        for (int j = 1; j <= k; j++)
        {
            ret = Next[ret];
            Hash = Hash * p + a[ret];
        }
        for (int l = k + 1; l <= 50; l++)
        {
            Insert(Hash, y);
            ret = Next[ret];
            if (!ret)
                break;
            Hash = Hash * p + a[ret];
        }
        now = Pre[now];
        if (!now)
            break;
    }
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        Insert(a[i], 1);
    }
    Pow[0] = 1;
    for (int i = 1; i <= 50; i++)
    {
        Pow[i] = Pow[i - 1] * p;
    }
    int op;
    int x, y;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d", &op);
        if (op == 1)
        {
            scanf("%d%d", &x, &y);
            Next[x] = y;
            Pre[y] = x;
            Change(x, 1);
        }
        else if (op == 2)
        {
            scanf("%d", &x);
            Change(x, -1);
            Pre[Next[x]] = 0, Next[x] = 0;
        }
        else
        {
            scanf("%s", str + 1);
            scanf("%d", &x);
            LL ret = 0;
            for (int i = 1; i <= x; i++)
                ret = ret * p + str[i] - '0';
            LL ans = Query(ret);
            LL len = strlen(str + 1);
            for (int i = x + 1; i <= len; i++)
            {
                ret = ret - (str[i - x] - '0') * Pow[x - 1];
                ret = ret * p + (str[i] - '0');
                ans = ans * Query(ret) % mod;
            }
            printf("%lld\n", ans);
        }
    }
}

BZOJ 4299 Codechef FRBSUM

Wed, 09 Aug 2017 21:24:05 GMT

Description

数集S的ForbiddenSum定义为无法用S的某个子集（可以为空）的和表示的最小的非负整数。例如，S={1,1,3,7}，则它的子集和中包含0(S’=∅)，1(S’={1})，2(S’={1,1})，3(S’={3})，4(S’={1,3})，5(S' = {1, 1, 3})，但是它无法得到6。因此S的ForbiddenSum为6。给定一个序列A，你的任务是回答该数列的一些子区间所形成的数集的ForbiddenSum是多少。

Input

输入数据的第一行包含一个整数N，表示序列的长度。接下来一行包含N个数，表示给定的序列A（从1标号）。接下来一行包含一个整数M，表示询问的组数。接下来M行，每行一对整数，表示一组询问。

Output

对于每组询问，输出一行表示对应的答案。

Sample Input

5
1 2 4 9 10
5
1 1
1 2
1 3
1 4
1 5

Sample Output

2
4
8
8
8

HINT

对于100%的数据，1≤N,M≤100000,1≤A_i≤10^9，1≤A_1+A_2+…+A_N≤10^9。

题解

可以看出

如果一个区间能组出1~n的数而且有一个数小于等于n+1
则这个区间一定能构造出 n+1

然后就可以了

用主席树维护一下就可以了

复习一下主席树

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF = 1e9;
struct Seg_Node
{
    int l, r;
    Seg_Node *ch[2];
    int Sum;
} * root[100005], *null;
int a[100005];
Seg_Node *NewSeg_Node()
{
    Seg_Node *S = new Seg_Node();
    S->ch[0] = S->ch[1] = null;
    return S;
}
void copy(Seg_Node *&a, Seg_Node *b)
{
    if (b == null)
        a = null;
    else
        a = NewSeg_Node(), *a = *b;
}
void Update(int v, int l, int r, Seg_Node *&rt1, Seg_Node *rt2)
{
    copy(rt1, rt2);
    if(rt1==null)
        rt1=NewSeg_Node();
    rt1->Sum += v;
    rt1->l = l, rt1->r = r;
    if (l == r)
        return;
    int m = l + r >> 1;
    if (v <= m)
    {
        Update(v, l, m, rt1->ch[0], rt2->ch[0]);
    }
    else
    {
        Update(v, m + 1, r, rt1->ch[1], rt2->ch[1]);
    }
}
int Query(int R, int l, int r, Seg_Node *rt1, Seg_Node *rt2)
{
    if (R >= r)
        return rt1->Sum - rt2->Sum;
    int m = l + r >> 1;
    if (R <= m)
        return Query(R, l, m, rt1->ch[0], rt2->ch[0]);
    return Query(R, l, m, rt1->ch[0], rt2->ch[0]) + Query(R, m + 1, r, rt1->ch[1], rt2->ch[1]);
}
int main()
{
    null = new Seg_Node();
    null->ch[0] = null->ch[1] = null;
    root[0] = null;
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++)
    {
        Update(a[i], 1, 1e9, root[i], root[i - 1]);
    }
    int m;
    scanf("%d", &m);
    int a, b, ans;
    while (m--)
    {
        scanf("%d%d", &a, &b);
        int res = 1;
        ans = min(INF, Query(res, 1, 1e9, root[b], root[a - 1]));
        while (ans >= res && res < 1e9)
        {
            res = ans + 1;
            ans = min(INF, Query(res, 1, 1e9, root[b], root[a - 1]));
        }
        printf("%d\n", ans + 1);
    }
}

permutation

Wed, 09 Aug 2017 20:45:13 GMT

3.1 题目描述

一个长度为n 的排列p[1..n] 把排列的每个循环拿出来，写成标准循环，再做一次排序比如[4, 1, 6, 2, 5, 3]，有3 个循环(421)(63)(5) 其中第一个循环就是4 要到2 的位置，2 要到1 的位置，1 要到4 的位置  每个循环从任意一个位置开始读都是一样的比如(412) 也是(124),(241)。n 个循环就一共n 个表达法我们规定一个标准循环是以循环内最大的数字开头循环之间排序的关键字就是第一个数字的大小如(421)(63)(5) 排序后是(421)(5)(63) 如果排序后的拍列和原排列一样，那么就是可行排列求n 个数的字典序第k 大的排列

3.2 输入格式

两个整数，n，k 保证k 在long long 范围内，保证有解

3.3 输出格式

n 个整数，表示满足条件的排列

3.4 Sample Input1

4 3

3.5 Sample Output1

1 3 2 4

3.6 Sample Input2

10 1

3.7 Sample Output2

1 2 3 4 5 6 7 8 9 10

3.8 数据范围及约定

对于30% 的数据满足：1 <= n <= 10 对于100% 的数据满足，1 <= n <= 50

题解

不要被卡读题

什么是循环

比如说题目中的例子

4本应在的位置为2在的位置
2本应在的位置为1在的位置
1本应在的位置为4在的位置
这就是一个循环

然后先打一个表找规律

我们会惊讶的发现他好像和斐波那契有关

而且只会有相邻的两个数调换

然后按照规律跑就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <deque>
using namespace std;
#define LL long long
LL f[55], Sum[55];
int a[55];
bool mark[55];
int main()
{
    LL n, k;
    scanf("%lld%lld", &n, &k);
    f[0] = f[1] = f[2] = 1;
    Sum[0] = 1, Sum[1] = 2, Sum[2] = 3;
    for (int i = 3; i <= n; i++)
    {
        f[i] = f[i - 1] + f[i - 2];
        Sum[i] = Sum[i - 1] + f[i];
    }
    for (int i = 1; i <= n; i++)
        a[i] = i;
    while (k > 1)
    {
        int j = lower_bound(Sum, Sum + n + 1, k) - Sum -1;
        k -= Sum[j];
        mark[n - j - 1] = mark[n - j] = 1;
    }
    for (int i = 1; i <= n; i++)
        if (mark[i] && mark[i + 1])
            mark[i] = mark[i + 1] = 0, swap(a[i], a[i + 1]);
    for (int i = 1; i <= n; i++)
        printf("%d ", a[i]);
    //while (1)
    ;
}

beautiful

Wed, 09 Aug 2017 20:37:20 GMT

2.1 题目描述

Mavis 有一个序列（不必在乎这些细节），对于每个数都有一个在序列中的优美值，这个优美值的定义是：找到序列中最长的一段，满足包含这个数并且这个数是这一段的中位数（以数值为第一关键字，下标为第二关键字排序, 这样的话这一段的长度只有可能是奇数），那么这一  段的长度就是它的优美值。Mavis 说：“对于我每次手贱点出的左右端点[l, r]，我都要找到[l, r] 中的所有数中，最大的优美值” 但是Mavis 只会喊口号，不能解决问题，所以这个问题就交给你了

2.2 输入格式

第一行输入n 接下来n 个整数，代表ai 接下来Q，代表有Q 个区间接下来Q 行，每行两个整数l, r(l <= r)，表示区间的左右端点

2.3 输出格式

对于每个区间的询问，输出答案

2.4 Sample Input

8
16 19 7 8 9 11 20 16
8
3 8
1 4
2 3
1 1
5 5
1 2
2 8
7 8

2.5 Sample Output

7
3
1
3
5
3
7
3

2.6 数据范围及约定

对于30% 的数据满足：1 <= n;Q <= 50 对于70% 的数据满足：1 <= n;Q < 2000 对于100% 的数据满足，1 <= n <= 2000, 1 <= Q <= 100000, 1 <= ai <= 200

题解

可以先预处理出一个数的最大的优美值
然后就查询就可以了，，区间最大

关键是预处理
可以用可持久化Trie N^2logN 求出每个区间的中位数
然后这个问题就解决了

先sort一遍在标号

#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
struct data
{
    int a, pos;
    bool operator<(const data &b) const
    {
        return a == b.a ? pos < b.pos : a < b.a;
    }
} a[2005];
int comp(const data &a, const data &b)
{
    return a.pos < b.pos;
}
int full = 13;
struct Trie
{
    struct Trie_Node
    {
        Trie_Node *ch[2];
        int s;
        Trie_Node()
        {
            ch[0] = ch[1] = NULL;
            s = 0;
        }
    } * root[2005], *null;
    Trie()
    {
        null = new Trie_Node();
        null->ch[0] = null->ch[1] = null;
        root[0] = new Trie_Node();
        root[0]->ch[1] = root[0]->ch[0] = null;
    }
    Trie_Node *NewNode()
    {
        Trie_Node *rt = new Trie_Node();
        rt->ch[0] = rt->ch[1] = null;
        return rt;
    }
    void copy(Trie_Node *&a, Trie_Node *b)
    {
        if (b == null)
            a = null;
        else
            a = NewNode(), *a = *b;
    }
    void Insert(int x, int cnt)
    {
        copy(root[cnt], root[cnt - 1]);
        Trie_Node *rt1 = root[cnt], *rt2 = root[cnt - 1];
        for (int i = full; i >= 0; i--)
        {
            int k = (x >> i) & 1;
            copy(rt1->ch[k], rt2->ch[k]);
            if (rt1->ch[k] == null)
                rt1->ch[k] = NewNode();
            rt1 = rt1->ch[k], rt2 = rt2->ch[k];
            rt1->s++;
        }
    }
    int kth(int k, int l, int r)
    {
        int res = 0;
        Trie_Node *rt1 = root[r], *rt2 = root[l - 1];
        for (int i = full; i >= 0; i--)
        {
            if (k > rt1->ch[0]->s - rt2->ch[0]->s)
            {
                k -= (rt1->ch[0]->s - rt2->ch[0]->s);
                res |= (1 << i);
                rt1 = rt1->ch[1], rt2 = rt2->ch[1];
            }
            else
            {
                rt1 = rt1->ch[0], rt2 = rt2->ch[0];
            }
        }
        return res;
    }
} root;
int pos[2005];
int Maxn[2005 << 2];
int Max[2005 << 2];
#define lch l, m, rt << 1
#define rch m + 1, r, rt << 1 | 1
void Update(int rt)
{
    Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
}
void buildtree(int l, int r, int rt)
{
    if (l == r)
    {
        Max[rt] = Maxn[l];
        return;
    }
    int m = l + r >> 1;
    buildtree(lch);
    buildtree(rch);
    Update(rt);
}
int Query(int L, int R, int l, int r, int rt)
{
    if (L <= l && R >= r)
        return Max[rt];
    int m = l + r >> 1;
    int MAX = 0;
    if (L <= m)
        MAX = max(MAX, Query(L, R, lch));
    if (R > m)
        MAX = max(MAX, Query(L, R, rch));
    return MAX;
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i].a);
        a[i].pos = i;
    }
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
    {
        a[i].a = i;
        pos[a[i].a] = a[i].pos;
    }
    sort(a + 1, a + n + 1, comp);
    for (int i = 1; i <= n; i++)
        root.Insert(a[i].a, i);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            if ((i - j + 1) & 1)
            {
                int k = pos[root.kth((i - j + 1) / 2 + 1, j, i)];
                Maxn[k] = max(Maxn[k], (i - j + 1));
            }
        }
    }
    buildtree(1, n, 1);
    int Q, l, r;
    scanf("%d", &Q);
    while (Q--)
    {
        scanf("%d%d", &l, &r);
        printf("%d\n", Query(l, r, 1, n, 1));
    }
}

calc

Wed, 09 Aug 2017 20:34:24 GMT

1.1 题目描述

给定一个序列a，a 中任意两个元素都不等。如果i<j, 且a[i]<a[j]，则我们称a[i],a[j] 为一个顺序对，这个顺序对的值是指a[i+1],a[i+2]…….a[j-1] 中比a[i] 大，且比a[j] 小的数的个数。求一个序列中所有顺序对的值的和。

1.2 输入格式

第一行n 然后n 个整数表示ai

1.3 输出格式

一个整数，表示答案

1.4 Sample Input

5
1 5 3 4 2

1.5 Sample Output

1

1.6 数据范围及约定

对于30% 的数据满足：1 <= n <= 300 对于另外30% 的数据满足：1 <= n <= 3000 对于100% 的数据满足，1 <= n <= 300000, 1 <= ai <= 10^9

题解

反正挺伤心的没有想到正确的方向

对于每一个数他对后面的数所造成的贡献就是
他前面比他小的数的个数

然后树状数组维护一下就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
long long Sum[2][300005];
#define lowbit(_) ((_) & (-_))
int n;
void add(int p, int x, int w)
{
    for (int i = x; i <= n; i += lowbit(i))
        Sum[p][i] += w;
}
long long Gsum(int p, int x)
{
    long long ans = 0;
    for (int i = x; i; i -= lowbit(i))
        ans += Sum[p][i];
    return ans;
}
int a[300005], Hash[300005];
int main()
{
    scanf("%d", &n);
    long long ans = 0;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        Hash[i] = a[i];
    }
    sort(Hash + 1, Hash + n + 1);
    int tot = unique(Hash + 1, Hash + n + 1) - Hash - 1;
    for (int i = 1; i <= n; i++)
        a[i] = lower_bound(Hash + 1, Hash + tot + 1,a[i]) - Hash;
    for (int i = 1; i <= n; i++)
    {
        int x = Gsum(0, a[i] - 1);
        add(0, a[i], 1);
        ans += Gsum(1, a[i] - 1);
        add(1, a[i], x);
    }
    printf("%lld\n", ans);
}

与非

Tue, 08 Aug 2017 20:13:12 GMT

题目描述

作为一名新世纪共产主义的接班人，你认识到了资本主义的软弱性与妥协性，决定全面根除资本主义，跑步迈入共产主义。但是当你即将跨入共产主义大门的时候，遇到了万恶的资本家留下的与非电路封印，经过千辛万苦的研究，你终于把复杂的破解转变成了以下问题：  初始时你有一个空序列，之后有N个操作。

操作分为一下两种：

1 x：在序列末尾插入一个元素x(x=0或1)。

2 L R：定义nand[L,R]为序列第L个元素到第R个元素的与非和，询问nand[L,L]^nand[L,L+1]^nand[L,L+2]^......^nand[L,R]。

Nand就是先与，再取反

输入

从文件nand.in中读入数据。

输入第一行一个正整数N，表示操作个数。

接下来N行表示N个操作。

为了体现程序的在线性，记lastans为上一次操作二的回答，初始lastans=0,。对于操作1，你需要对x异或lastans。对于操作二，设现在序列中的元素个数为M，如果lastans=1，那么你需要作如下操作：L=M-L+1,R=M-R+1,swap(L,R)

输出

输出到nand.out中。

输出有多行。为对于每一个操作二的回答。

样例输入

6
1 1
1 1
1 0
2 1 2
2 1 3
2 2 3

样例输出

1
0
0

【数据规模和约定】

数据点 N的规模操作一的个数M1 操作二的个数M2

1 N<=1000 M1<=500 M2<=500 2 N<=1000 M1<=500 M2<=500 3 N<=200000 M1<=100000 M2<=100000 4 N<=200000 M1<=100000 M2<=100000 5 N<=1000000 M1<=900000 M2<=100000 N<=4000000 M1<=3900000 M2<=100000

题解

想了好久也没想出来最后放弃了

其实可以分类讨论

最后会发现一个结论

#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;
inline int read()
{
    int s = 0, k = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
        k = ch == '-' ? -1 : k, ch = getchar();
    while (ch >= '0' && ch <= '9')
        s = s * 10 + (ch ^ 48), ch = getchar();
    return s * k;
}
int n;
bool Sum[4000005];
bool f[4000005];
bool a[4000005];
int main()
{
    n = read();
    int t = 0, op, l, r;
    int lastans = 0;
    while (n--)
    {
        op = read();
        if (op == 1)
        {
            l = read() ^ lastans;
            t++;
            a[t] = l;
            if (t == 1)
                f[t] = a[t];
            else
                f[t] = !(f[t - 1] & l);
            Sum[t] = Sum[t - 1] ^ f[t];
        }
        else
        {
            l = read(), r = read();
            if (lastans)
            {
                l = t - l + 1;
                r = t - r + 1;
                swap(l, r);
            }
            lastans = a[l];
            int i = l, now = !(a[l] & a[l + 1]);
            while (now != f[i + 1] && i < r)
            {
                lastans ^= now;
                i++;
                now = !(now & a[i + 1]);
            }
            if (i < r)
            {
                lastans ^= Sum[r] ^ Sum[i];
            }
            printf("%d\n", lastans);
        }
    }
    //while (1);
}

Number

Tue, 08 Aug 2017 20:07:55 GMT

题目描述

一个排列，求出了 a 数组，其中 ai 表示第 i 个数左边有多少个数比它小

计算出原来的排列

输入

第一行输入 n 接下来 n - 1 个整数 ai，下标从 2 开始

输出

输出 n 个整数表示原排列

样例输入

5
1
2
1
0

样例输出

2
4
5
3
1

提示

对于 20% 的数据满足：1 ≤ n ≤ 10 对于 50% 的数据满足：1 ≤ n ≤ 1000 对于 100% 的数据满足，1 ≤ n ≤ 100000 保证解存在

题解

输入的树就是按顺序插入时比他小的数的数量
用一颗平衡树维护就可以了

#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;
struct Node
{
    Node *ch[2];
    int s, id, key;
    Node(int x)
    {
        key = rand();
        id = x;
        s = 1;
        ch[0] = ch[1] = NULL;
    }
#define size(_) ((_) ? (_)->s : 0)
    void Update()
    {
        s = size(ch[1]) + size(ch[0]) + 1;
    }
} * root;
Node *Merge(Node *A, Node *B)
{
    if (!A)
        return B;
    if (!B)
        return A;
    if (A->key < B->key)
    {
        A->ch[1] = Merge(A->ch[1], B);
        A->Update();
        return A;
    }
    else
    {
        B->ch[0] = Merge(A, B->ch[0]);
        B->Update();
        return B;
    }
}
typedef pair<Node *, Node *> DNode;
DNode Split(Node *rt, int k)
{
    if (!rt)
        return DNode(NULL, NULL);
    DNode o;
    if (size(rt->ch[0]) >= k)
    {
        o = Split(rt->ch[0], k);
        rt->ch[0] = o.second;
        rt->Update();
        o.second = rt;
    }
    else
    {
        o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
        rt->ch[1] = o.first;
        rt->Update();
        o.first = rt;
    }
    return o;
}
void Insert(int x, int k)
{
    DNode y = Split(root, k);
    Node *n = new Node(x);
    root = Merge(y.first, Merge(n, y.second));
}
int Ind = 0;
int a[100005];
void DFS(Node *rt)
{
    if (rt)
    {
        DFS(rt->ch[0]);
        a[rt->id] = ++Ind;
        DFS(rt->ch[1]);
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    int c;
    Insert(1, 0);
    for (int i = 2; i <= n; i++)
    {
        scanf("%d", &c);
        Insert(i, c);
    }
    DFS(root);
    for (int i = 1; i <= n; i++)
    {
        printf("%d\n", a[i]);
    }
    //while(1);
}

Evensgn 的债务

Tue, 08 Aug 2017 19:58:44 GMT

题目描述

Evensgn 有一群好朋友，他们经常互相借钱。假如说有三个好朋友 A，B，C。

A 欠 B 20 元，B 欠 C 20 元，总债务规模为 20+20=40 元。Evensgn 是个追求简约  的人，他觉得这样的债务太繁杂了。他认为，上面的债务可以完全等价为 A 欠 C

20 元，B 既不欠别人，别人也不欠他。这样总债务规模就压缩到了 20 元。

现在给定 n 个人和 m 条债务关系。Evensgn 想找到一种新的债务方案，使得

每个人欠钱的总数不变，或被欠钱的总数不变（但是对象可以发生变化），并且使

得总债务规模最小。

输入

输入文件第一行两个数字 n; m，含义如题目所述。

接下来 m 行，每行三个数字 ai; bi; ci，表示 ai 欠 bi 的钱数为 ci。

注意，数据中关于某两个人 A 和 B 的债务信息可能出现多次，将其累加即可。

如”A 欠 B 20 元”、”A 欠 B 30 元”、”B 欠 A 10 元”，其等价为”A 欠 B 40 元”。

输出

输出文件共一行，输出最小的总债务规模。

样例输入

样例输入 1
5 3
1 2 10
2 3 1
2 4 1
样例输入 2
4 3
1 2 1
2 3 1
3 1 1

样例输出

样例输出 1
10
样例输出 2
0

题解

考试的时候想了想
发现可以理解为
每一个人将他的真正的需要交出的钱一起交出
然后就需要拿钱的人去拿
统计一下就可以了

#include <cstdio>
#include <algorithm>
using namespace std;
int in[1000005], out[1000005];
long long Sum = 0;
int main()
{
    int n, m, a, b, c;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        out[a] += c;
        in[b] += c;
        Sum += c;
    }
    for (int i = 1; i <= n; i++)
    {
        Sum -= min(out[i], in[i]);
    }
    printf("%lld\n", Sum);
    //while (1)
}

HDU1693 Eat the Trees && BZOJ 1210 [HNOI2004] 邮递员

Tue, 08 Aug 2017 19:23:32 GMT

先来一个最入门的 HDU 1693

哈密顿回路多回路

Problem Description

Most of us know that in the game called DotA(Defense of the Ancient), Pudge is a strong hero in the first period of the game. When the game goes to end however, Pudge is not a strong hero any more. So Pudge’s teammates give him a new assignment—Eat the Trees!  The trees are in a rectangle N * M cells in size and each of the cells either has exactly one tree or has nothing at all. And what Pudge needs to do is to eat all trees that are in the cells. There are several rules Pudge must follow: I. Pudge must eat the trees by choosing a circuit and he then will eat all trees that are in the chosen circuit. II. The cell that does not contain a tree is unreachable, e.g. each of the cells that is through the circuit which Pudge chooses must contain a tree and when the circuit is chosen, the trees which are in the cells on the circuit will disappear. III. Pudge may choose one or more circuits to eat the trees.

Now Pudge has a question, how many ways are there to eat the trees? At the picture below three samples are given for N = 6 and M = 3(gray square means no trees in the cell, and the bold black line means the chosen circuit(s))

Input

The input consists of several test cases. The first line of the input is the number of the cases. There are no more than 10 cases. For each case, the first line contains the integer numbers N and M, 1<=N, M<=11. Each of the next N lines contains M numbers (either 0 or 1) separated by a space. Number 0 means a cell which has no trees and number 1 means a cell that has exactly one tree.

Output

For each case, you should print the desired number of ways in one line. It is guaranteed, that it does not exceed 263 – 1. Use the format in the sample.

Sample Input

2
6 3
1 1 1
1 0 1
1 1 1
1 1 1
1 0 1
1 1 1
2 4
1 1 1 1
1 1 1 1

Sample Output

Case 1: There are 3 ways to eat the trees.
Case 2: There are 2 ways to eat the trees.

本题就是一道最基础的求回路的题目
因为我们不需要要求一条回路，所以只需记录是否有插头就可以了

#include <cstdio>
#include <cstring>
using namespace std;
const int Max = (1 << 12) + 10;
int n, m;
int mp[12][12];
long long DP[12][12][Max];

void dp()
{
    memset(DP, 0, sizeof(DP));
    DP[0][m][0] = 1;
    int bit = 1 << (m + 1);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j < (bit >> 1); j++)
        {
            DP[i][0][j << 1] = DP[i - 1][m][j];
        }
        for (int j = 1; j <= m; j++)
        {
            for (int k = 0; k < bit; k++)
            {
                int x = 1 << (j - 1);
                int y = 1 << j;
                if (mp[i][j])
                {
                    DP[i][j][k] += DP[i][j - 1][k ^ x ^ y];
                    if ((k & x) && (k & y))
                        continue;
                    if (!(k & x) && !(k & y))
                        continue;
                    DP[i][j][k] += DP[i][j - 1][k];
                }
                else
                {
                    if (!(k & x) && !(k & y))
                        DP[i][j][k] = DP[i][j - 1][k];
                    else
                        DP[i][j][k] = 0;
                }
            }
        }
    }
}
int main()
{
    int t, num = 0;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                scanf("%d", &mp[i][j]);
            }
        }
        dp();
        printf("Case %d: There are %lld ways to eat the trees.\n", ++num, DP[n][m][0]);
    }
    //while(1);
}

然后是稍微复杂点的

单回路

【题目描述】

Smith在P市的邮政局工作，他每天的工作是从邮局出发，到自己所管辖的所有邮筒取信件，然后带回邮局。他所管辖的邮筒非常巧地排成了一个m*n的点阵（点阵中的间距都是相等的）。左上角的邮筒恰好在邮局的门口。 Smith是一个非常标新立异的人，他希望每天都能走不同的路线，但是同时，他又不希望路线的长度增加，他想知道他有多少条不同的路线可走。

你的程序需要根据给定的输入，给出符合题意的输出： l 输入包括点阵的m和n的值； l 你需要根据给出的输入，计算出Smith可选的不同路线的总条数；

【输入格式】

输入文件postman.in只有一行。包括两个整数m, n(1 <= m <= 10, 1 <= n <= 20)，表示了Smith管辖内的邮筒排成的点阵。

【输出格式】

输出文件只有一行，只有一个整数，表示Smith可选的不同路线的条数。【样例输入】

2 2 说明：该输入表示，Smith管辖了2*2的一个邮筒点阵。【样例输出】

2 【提示】

详情请看代码

#include <cstdio>
#include <cstring>
#include <deque>
using namespace std;
#define LL long long
const int BA = 100000, SIZEN = 10, SIZEM = 20, BASE = 200000;
int N, M;
int H[BASE];
class BigNum /**高精度 */
{
  public:
    int n;
    int s[50];
    void operator=(int a)
    {
        n = 1;
        memset(s, 0, sizeof(s));
        s[0] = a;
    }
    void operator+=(BigNum a)
    {
        n = max(n, a.n) + 1;
        for (int i = 0; i <= n; i++)
        {
            s[i] += a.s[i];
            s[i + 1] += s[i] / BA;
            s[i] %= BA;
        }
        while (n > 0 && s[n - 1] == 0)
        {
            n--;
        }
    }
    void operator*=(int a)
    {
        n++;
        for (int i = 0; i <= n; i++)
            s[i] *= a;
        for (int i = 0; i <= n; i++)
        {
            s[i + 1] += s[i] / BA;
            s[i] %= BA;
        }
        while (n > 0 && s[n - 1] == 0)
        {
            n--;
        }
    }
    void print()
    {
        printf("%d", s[n - 1]);
        for (int i = n - 2; i >= 0; i--)
            printf("%05d", s[i]);
    }
} ans;

class Pair /**映射表 */
{
  public:
    BigNum Sum;
    LL Id;
    Pair() {}
    Pair(LL a, BigNum b)
    {
        Id = a;
        Sum = b;
    }
};
deque<Pair> f[2]; /**循环数组 */
void read()       /**read */
{
    scanf("%d%d", &N, &M);
    if (N < M)
        swap(N, M);
}
int Get(int x, int j) /**取4进制的操作 */
{
    x >>= 2 * (j - 1);
    x &= 3;
    return x;
}
int Change(int x, int j, int t) /**把x的第j位改成t */
{
    int tmp = x >> (2 * (j - 1));
    x -= tmp << (j - 1) * 2;
    tmp >>= 2;
    x += tmp << 2 * j;
    x += t << ((j - 1) * 2);
    return x;
}
int Find(int x, int j, int dat) /**找与他相连的括号 */
{
    int now = dat, k = j;
    while (k >= 1 && k <= M + 1)
    {
        k += now;
        int tmp = Get(x, k);
        if (tmp == 1)
            dat++;
        if (tmp == 2)
            dat--;
        if (dat == 0)
            return k;
    }
}
void Push(int k, int Id, BigNum Sum) /**插入hash表 */
{
    int now = Id % BASE;
    while (H[now]) /**如果有 */
    {
        if (f[k][H[now]].Id == Id) /**且就是这个状态 */
        {
            f[k][H[now]].Sum += Sum; /**加值，和并答案 */
            return;
        }
        now++; /**找自己的状态 */
        if (now == BASE)
            now = 0;
    }
    H[now] = f[k].size(); /**如果第一次出现 */
    f[k].push_back(Pair(Id, Sum));
}
/**
 * 1为左括号
 * 2为右括号
 * 0为无括号
 */
void DP()
{
    int k = 0;
    BigNum p;
    p = 1; /**初始化状态 */
    f[k].push_back(Pair(0, p));
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
        {
            k ^= 1;                  /**滚动数组 */
            f[k].clear();            /**清空本维 */
            memset(H, 0, sizeof(H)); /**hash 数组 */
            for (int m = 0; m < f[k ^ 1].size(); m++)
            {
                int Id = f[k ^ 1][m].Id;       /**取状态 */
                BigNum date = f[k ^ 1][m].Sum; /**取值 */
                int L = Get(Id, j), U = Get(Id, j + 1);
                /**
                 * L:左面的 ，U: 右面的
                 */
                int tmp;      /**分类讨论开始 */
                if (!L && !U) /**两个插头都是无插头状态 */
                {
                    if (i != N && j != M) /**如果不是最后一个 */
                    {
                        tmp = Change(Id, j, 1); /**构造一组新的括号 */
                        tmp = Change(tmp, j + 1, 2);
                        Push(k, tmp, date); /**插入Hash */
                    }
                }
                else if (!L && U) /**左面的没有 */
                {
                    if (j != M)            /**向右转移 */
                        Push(k, Id, date); /**延续状态 当j==M事不能向右动*/
                    if (i != N)            /**向下转移 */
                    {
                        /**将L,U位置的 状态互换 转移*/
                        tmp = Change(Id, j, U);
                        tmp = Change(tmp, j + 1, 0);
                        Push(k, tmp, date);
                    }
                }
                else if (L && !U) /**上面的没有 */
                {
                    if (i != N) /**向下 */
                        Push(k, Id, date);
                    if (j != M) /**向右 */
                    {
                        /**于上同理 */
                        tmp = Change(Id, j, 0);
                        tmp = Change(tmp, j + 1, L);
                        Push(k, tmp, date);
                    }
                }
                else if (L == 1 && U == 1) /**两个都是左括号 */
                {
                    tmp = Change(Id, Find(Id, j + 1, 1), 1); /**将与上面相连的右括号转为左括号 */
                    tmp = Change(tmp, j, 0);                 /**这两位都制为无括号 */
                    tmp = Change(tmp, j + 1, 0);
                    Push(k, tmp, date);
                }
                else if (L == 2 && U == 2)                /**两个都是右括号 */
                {                                         /**与上面对称 */
                    tmp = Change(Id, Find(Id, j, -1), 2); /**将与左面相连的左括号制为右括号 */
                    tmp = Change(tmp, j, 0);               /**这两位都为无括号 */
                    tmp = Change(tmp, j + 1, 0);
                    Push(k, tmp, date);
                }
                else if (L == 2 && U == 1) /**左插头为右括号 上插头为左括号 */
                {                          /**都制为无 */
                    tmp = Change(Id, j, 0);
                    tmp = Change(tmp, j + 1, 0);
                    Push(k, tmp, date);
                }
                else if (L == 1 && U == 2)
                {
                    if (i == N && j == M)
                        ans += date;
                }
            }
        }
        for (int km = 0; km < f[k].size(); km++) /**提前换行准备为下一行使用 */
            f[k][km].Id <<= 2;
    }
    ans *= 2;
    ans.print();
}
int main()
{
    //freopen("postman.in", "r", stdin);
    //freopen("postman.out", "w", stdout);
    read();
    if (M == 1)
    {
        printf("1");
        return 0;
    }
    DP();
    return 0;
}

书

Tue, 08 Aug 2017 13:10:59 GMT

题目描述

Hazel有n本书，编号1为n到，叠成一堆。当她每次抽出一本书的时候，上方的书会因重力而下落，这本被取出的书则会被放置在书堆顶。每次有pi的概率抽取编号为i的书。她每次抽书所消耗的体力与这本书在这堆中是第几本成正比。具体地，抽取堆顶的书所耗费体力值为1 ，抽取第二本耗费体力值为2 ，以此类推。  现在想知道，在很久很久以后（可以认为几乎是无穷的），她每次抽书所耗费的体力的期望值是多少。最终的答案显然可以表示成a/b的形式，请输出a*(b^-1)模1e9+7的值。

【输入格式】

第一行一个整数n 接下来n行，每行两个整数ai，bi，代表抽取第i本书的概率是ai/bi 保证所有书的概率和等于1

【输出格式】

输出一行一个整数，代表期望值

【输入样例1】

2
227494 333333
105839 333333

【输出样例1】

432679642

【输入样例2】

10
159073 999999
1493 142857
3422 333333
4945 37037
2227 111111
196276 999999
190882 999999
142721 999999
34858 999999
101914 999999

【输出样例2】

871435606

【数据规模与约定】

对于30%的数据，1<=n<=10。对于100%的数据，1<=n<=1000,0<=ai<=bi,bi!=0。

题解

期望DP

P表示概率 E表示期望体力

$$ Ans = \sum_{i=1}^{n}{P_iE_i} $$ $$ = \sum_{i=1}^{n}{P_i(1+\sum_{j=1且就i!=j}^{n}{P_{抽到j比i晚}})}$$ $$ = \sum_{i=1}^{n}{P_i*(1+\sum_{j=1且j!=i}^{n}{\frac{P_j}{P_i+P_j}})}$$

#include <cstdio>
#include <cstring>
using namespace std;
#define LL long long
const LL P = 1e9 + 7;
LL pow_mod(LL a, int b)
{
    LL ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % P;
        b >>= 1;
        a = a * a % P;
    }
    return ans;
}
LL q[1005];
int main()
{
    int n;
    scanf("%d", &n);
    LL a, b;
    for (int i = 1; i <= n; i++)
    {
        scanf("%lld%lld", &a, &b);
        q[i] = a * pow_mod(b, P - 2) % P;
    }
    LL ans = 0;
    for (int i = 1; i <= n; i++)
    {
        LL sum = 0;
        for (int j = 1; j <= n; j++)
        {
            if (j == i)
                continue;
            sum = (sum + q[j] * pow_mod(q[i] + q[j], P - 2) % P) % P;
        }
        ans = (ans + (1 + sum) * q[i]) % P;
    }
    printf("%lld", ans);
}

就

Tue, 08 Aug 2017 12:53:42 GMT

【背景描述】

一排 N 个数，第 i 个数是 Ai ，你要找出 K 个不相邻的数，使得他们的和最大。请求出这个最大和。

【输入格式】

第一行两个整数 N 和 K。接下来一行 N 个整数，第 i 个整数表示 Ai 。

【输出格式】

一行一个整数表示最大和，请注意答案可能会超过 int 范围

【样例输入】

3 2
4 5 3

【样例输出】

7

【数据范围】

对于 20% 的数据， N, K ≤ 20 。对于 40% 的数据， N, K ≤ 1000 。对于 60% 的数据， N, K ≤ 10000 。对于 100% 的数据， N, K ≤ 100000 ， 1 ≤ Ai ≤ 1000000000。

题解

贪心，每次用一个堆维护最大值每次都找最大的和他两边的合并，其实是一个可反悔的贪心

主要边界处理

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <list>

using namespace std;

#define LL long long

struct data
{
    LL Num;
    int pos;
    bool operator<(const data &a) const
    {
        return Num == a.Num ? pos < a.pos : Num > a.Num;
    }
};

set<data> st;

LL a[100005];
int nex[100005], fre[100005];

LL Merge()
{
    int A = st.begin()->pos;
    LL ans = a[A];
    a[A] = -a[A];
    a[A] += a[fre[A]], a[A] += a[nex[A]];
    st.erase(st.begin());
    st.erase((data){a[fre[A]], fre[A]});
    st.erase((data){a[nex[A]], nex[A]});
    st.insert((data){a[A], A});
    if (fre[fre[A]])
        nex[fre[fre[A]]] = A;
    if (nex[nex[A]])
        fre[nex[nex[A]]] = A;
    fre[A] = fre[fre[A]];
    nex[A] = nex[nex[A]];
    return ans;
}
int main()
{
    int n, k;
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%lld", &a[i]);
        fre[i] = i - 1;
        nex[i] = i + 1;
        st.insert((data){a[i], i});
    }
    nex[n] = 0;
    a[0] = 0x8080808080808080ll;
    LL ans = 0;
    while (k--)
    {
        ans += Merge();
    }
    printf("%lld", ans);
}

Passward

Tue, 08 Aug 2017 12:52:32 GMT

题目描述

你来到了一个庙前，庙牌上有一个仅包含小写字母的字符串 s。传说打开庙门的密码是这个字符串的一个子串 t，并且 t 既是 s 的前缀又是 s 的后缀并且还在 s 的中间位置出现过一次。  如果存在这样的串，请你输出这个串，如有多个满足条件的串，输出最长的那一个。如果不存在这样的串，输出"Just a legend"(去掉引号)。

输入格式：

仅一行，字符串 s。

输出格式：

如题所述

样例输入

fixprefixsuffix

样例输出：

fix

数据范围：

对于 60%的数据， s 的长度<=100 对于 100%的数据， s 的长度<=100000

题解

hash 淼之

#include<cstdio>
#include<cstring>
using namespace std;
char s[2000005];
unsigned long long base = 31;
unsigned long long has[2000005];
unsigned long long Pow(unsigned long long b,int i)
{
    unsigned long long ans = 1;
    while(i)
    {
        if(i & 1)
            ans = ans * b;
        i >>= 1;
        b = b * b;
    }
    return ans;
}
int main()
{
    freopen("fool.in","r",stdin);
    freopen("fool.out","w",stdout);
    int q;
    scanf("%d",&q);
    while(q--){
        scanf("%s", s + 1);
        int len = strlen(s + 1);
        for (int i = 1; i <= len; i++)
        {
            has[i] = has[i - 1] * base + s[i];
        }
        int ans = 0;
        for (int i = 1; i <= len; i++)
        {
            unsigned long long T = Pow(base, i); 
            if( has[i] == has[len] - has[len - i] * T)
            {
                for(int j = 2; j < len - i; j++)
                {
                    if(has[j + i] - has[j] * T == has[i])
                    {
                        ans = i;
                        break;
                    }
                }
                if(ans != i)
                    break;
            }
        }
        if(ans)
        {
            for(int i = 1; i <= ans; i++)
            {
                printf("%c", s[i]);
            }
            printf("\n");
        }
        else 
            puts("---\n");
    }
}

K-D 树

Mon, 07 Aug 2017 15:04:53 GMT

维护K维的点

线段树相当于一颗1-D树

建树

循环建树
最大方差建树

怎么用

计算几何初步

Sun, 06 Aug 2017 20:53:59 GMT

1.什么是计算几何

维基百科计算几何

计算几何是一门兴起于二十世纪七十年代末的计算机科学的一个分支，主要研究解决几何问题的算法。  简单来说就是用计算机算解析几何

2.计算几何的恶心之处

有精度误差^1
需要讨论各种边界情况
代码长（看一看NOI2017D2T3的标称就知道了）

解决精度问题
设$\epsilon$为非常小的量
- $a=b \Leftrightarrow |a-b|< \epsilon$
- $a< b \Leftrightarrow a-b < -\epsilon$
- $a\leq b \Leftrightarrow a - b < \epsilon$

3.二维矢量

矢量

既有大小又有方向的量
又称为向量

矢量的表示

在n维空间下，矢量经常被表示为 $\vec{a}=(a_1,a_2,\ldots,a_n)$
在二维空间中则以$(x,y)$来表述

点积

$(a_1,a_2,\ldots,a_n)\cdot(b_1,b_2,\ldots,b_n) = a_1 b_1 + a_2 b_2+\cdots+ a_n b_n$

矢量的模

矢量的长度

! 二维叉积

$(x_1,y_1)\times(x_2,y_2) = x_1 y_2 - x_2 y_1$

二维叉积满足逆交换律: $\vec{a}\times\vec{b} = - \vec{b}\times\vec{a}$

有向面积

由$\vec{a}$和$\vec{b}$所成的平行四边形的面积为$|\vec{a}\times\vec{b}|$ 的值
去掉绝对值二维叉积定义为有向面积

有向面积的符号

伸出右手将四指由$\vec{a}$沿小于平角转到$\vec{b}$ 若拇指指向纸面上方则$\vec{a}\times\vec{b}$ 为正否则为负

二维矢量的旋转

将矢量$\vec{a}$逆时针旋转$\theta$后为$ \begin{pmatrix} \cos\theta & -\sin\theta \ \sin\theta & \cos\theta \ \end{pmatrix} \vec{a} $

二维矢量的极角

极角指示矢量的方向，以x轴正半轴逆时针转过的角度来指示矢量$(x,y)$的极角为$atan2(y,x)$

直线

用两个相异点来表示 $\forall\lambda \in R,\lambda A +(1-\lambda)B$ 表示直线上任意一点

点到直线的距离

点$P$到直线$AB$的距离即$|\vec{AP}-\vec{AB}\frac{\vec{AB}\cdot\vec{AP}}{\vec{AB}^2}|$

分点

若A,B,C共线，且$\frac{|\vec{AC}|}{\vec{CB}} =\frac{\lambda_1}{\lambda_2}$ 则$C=\frac{\lambda_2 A + \lambda_1 B}{\lambda_1 + \lambda_2}$

三角形的面积

$ S(\Delta ABC) = \frac{|\vec{AB}\times\vec{AC}|}{2}$

两直线交点

$\frac{|\vec{AO}|}{|\vec{OB}|} = \frac{S(\Delta ADC)}{S(\Delta BCD)} = \frac {\vec{AD}\times\vec{AC}}{\vec{BC}\times\vec{BD}}$

为完待续.....(2017-8-6)

[GDOI2014] 拯救莫莉斯

Sun, 06 Aug 2017 20:51:44 GMT

问题描述

莫莉斯·乔是圣域里一个叱咤风云的人物，他凭借着自身超强的经济头脑，牢牢控制了圣域的石油市场。

圣域的地图可以看成是一个n*m的矩阵。每个整数坐标点(x , y)表示一座城市（1<=x<= n, 1<=y<=m）。两座城市间相邻的定义为：对于城市$(A_x, A_y)$和城市$(B_x, B_y)$，满足$(A_x - B_x)^2 + (A_y - B_y)^2 = 1$。由于圣域的石油贸易总量很大，莫莉斯意识到不能让每笔石油订购单都从同一个油库里发货。为了提高效率，莫莉斯·乔决定在其中一些城市里建造油库，最终使得每一个城市X都满足下列条件之一：  1.该城市X内建有油库，

2.某城市Y内建有油库，且城市X与城市Y相邻。

与地球类似，圣域里不同城市间的地价可能也会有所不同，所以莫莉斯想让完成目标的总花费尽可能少。如果存在多组方案，为了方便管理，莫莉斯会选择建造较少的油库个数。

输入格式

第一行两个正整数n,m ( n * m <= 50 且m<=n)，表示矩阵的大小。

接下来一个n行m列的矩阵F，Fi, j表示在城市(i,j)建造油库的代价。

输出格式

输出两个数，建造方案的油库个数和方案的总代价。

输入样例：

3 3
6 5 4
1 2 3
7 8 9

输出样例：

3 6

数据范围

对于30%数据满足 n * m <= 25; 对于100%数据满足n * m <= 50; 0 <= Fi, j <= 100000

题解

按照题目的定义，第i行的状态，只会对i-1行至i+1行产生影响 F[i][j][k] 为对于前i行，第i-1行状态为j，第i行的状态为k，并且对于任意一行x（x<i），该行的所有城市满足题目的要求（附近城市里有油库）  F[i][j][k]的值表示其所能达到的最小代价（辅助数组G[i][j][k] 表示F[i][j][k]所对应方案里的油库数量）

F[i+1][k][X] = min(F[i][j][k] + cost[i+1][X]); (0 <= X <= 2m )

cost[i][j] 表示第i行，所取状态为j时所需要花费的代价。

转移方程中，X状态可取，需使第i行的所有城市满足要求，即： (X|j|k|(k<<1)|(k>>1))&(2^m-1)=2^m-1 答案：max(F[n+1][x][0])(0<=X<=2m)

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int F[52][(1 << 8) + 1][(1 << 8) + 1], G[52][(1 << 8) + 1][(1 << 8) + 1];
int a[55][55], n, m, N;
int check(int x, int S)
{
    int ans = 0;
    for (int i = 1; i <= m; i++)
    {
        if (((1 << (i - 1)) & S))
            ans += a[x][i];
    }
    return ans;
}
int Get_num(int x)
{
    int ans = 0;
    while (x)
    {
        if (x & 1)
            ans++;
        x >>= 1;
    }
    return ans;
}
int main()
{
    //freopen("proj.in", "r", stdin);
    //freopen("proj.out", "w", stdout);
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            scanf("%d", &a[i][j]);
    memset(F, 0x3f, sizeof(F));
    N = (1 << m) - 1;
    for (int i = 0; i <= N; i++)
    {
        //if ((((i >> 1) | (i << 1) | i) & N) == N)
        //{
            int ans = check(1, i);
            F[1][0][i] = ans;
            G[1][0][i] = Get_num(i);
        //}
    }
    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= N; j++)
            for (int k = 0; k <= N; k++)
                for (int m = 0; m <= N; m++)
                    if (((j | k | m | (k << 1) | (k >> 1)) & (N)) == N)
                    {
                        if (F[i][j][k] + check(i + 1, m) < F[i + 1][k][m])
                        {
                            F[i + 1][k][m] = F[i][j][k] + check(i + 1, m);
                            G[i + 1][k][m] = G[i][j][k] + Get_num(m);
                        }
                    }
    int ans = 0x3f3f3f4f, num = 0;
    for (int i = 0; i <= N; i++)
    {
        if (F[n + 1][i][0] < ans)
        {
            ans = F[n + 1][i][0];
            num = G[n + 1][i][0];
        }
        else if (F[n + 1][i][0] == ans)
        {
            if (num > G[n + 1][i][0])
                num = G[n + 1][i][0];
        }
    }
    printf("%d %d", num, ans);
    //while (1)
    ;
}

选美

Sun, 06 Aug 2017 20:42:41 GMT

【题目描述】

一年一度的星哥选美又拉开了帷幕

N个人报名参加选拔，每个人都有着各自的相貌参数和身材参数（不大于 10000 的正整数）。你的任务是尽可能让更多人被星哥选中，而唯一要求就是，在这只队伍里面的每个人，都需满足以下不等式：  $A (H− h) +B(W− w) ≤ C$

其中H和W为这个人的相貌和身材， h和w为选中者中的最小相貌参数和最小身材参数，而A、 B、 C为三个不大于 10000 的正的整型常数。

现在请计算星哥最多可以选中多少人。

【输入格式】

第一行：一个整数： N(0<N<=2000)

第二行：三个分开的整数： A,B和C

第三行到第N+ 2行：每行有两个用空格分开的整数，分别表示一个人的相貌参数和身材参数

【输出格式】

第一行：最多被选的人数

【输入样例】

8
1 2 4
5 1
3 2
2 3
2 1
7 2
6 4
5 1
4 3

【输出样例】

5

题解

只有$n^2\log_2{n}$的算法

先按H排序

枚举每一个h

然后将他后面的部分再按w排序

由树状树状维护前缀和就可以求出来了

/*
 * @Author: WildRage 
 * @Date: 2017-08-06 17:57:21 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-08-07 19:11:10
 */
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
struct data
{
    int h, w;
} a[2005], b[2005];
int n, A, B, C, m;
int comp(const data &a, const data &b)
{
    return a.h < b.h;
}
int cmp(const data &a, const data &b)
{
    return a.w < b.w;
}
int c[2005];
int lowbit(int x)
{
    return x & (-x);
}
void add(int x, int w)
{
    for (int i = x; i <= m; i += lowbit(i))
        c[i] += w;
}
int sum(int x)
{
    int s = 0;
    for (int i = x; i; i -= lowbit(i))
        s += c[i];
    return s;
}
int ans = 0;
void solve(int from)
{
    int h_min = a[from].h, w_min;
    int all;
    memcpy(b, a, sizeof(b));
    memset(c, 0, sizeof(c));
    sort(b + from, b + n + 1, cmp);
    int Sum[2005], Hash[2005];
    for (int i = from; i <= n; i++)
        Hash[i] = Sum[i] = b[i].h * A + b[i].w * B;
    sort(Hash + from, Hash + n + 1);
    m = unique(Hash + from, Hash + n + 1) - Hash - 1;
    for (int i = from; i <= n; i++)
    {
        int x = upper_bound(Hash + from, Hash + m + 1, Sum[i]) - Hash - 1;
        add(x, 1);
    }
    for (int i = from; i <= n; i++)
    {
        w_min = b[i].w;
        all = C + A * h_min + B * w_min;
        int x = upper_bound(Hash + from, Hash + m + 1, all) - Hash - 1;
        ans = max(ans, sum(x));
        add(upper_bound(Hash + from, Hash + m + 1, Sum[i]) - Hash - 1, -1);
    }
}
int main()
{
    //freopen("beauty.in", "r", stdin);
    //freopen("beauty.out", "w", stdout);
    scanf("%d", &n);
    scanf("%d%d%d", &A, &B, &C);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a[i].h, &a[i].w);
    }
    sort(a + 1, a + n + 1, comp);
    for (int i = 1; i <= n; i++)
        solve(i);
    printf("%d", ans);
}

天鹅会面

Sun, 06 Aug 2017 20:34:46 GMT

题目描述

两头白天鹅生活在一个部分湖面结了冰的湖泊中，湖面的形状为一个长方形，并且被分割成R行C列的小方格，某些方格中结了冰，这样的方格称之为冰格，其余的方格称之为水格。冬天过去了，湖面上的冰渐渐开始溶解了，每一天与水相邻的冰格就将消融而转化为水格。所谓两个方格相邻是指它们在水平或垂直方向有公共边，两个呈对角的方格是不相邻的，下图给出样例数据的演化过程。  白天鹅只能在水中沿水平或垂直方向游动，写一个程序判断多少天后两只白天鹅才能够相会。

【输入格式】

输入文件第一行包含两个用空格隔开的整数R和C，其中1 ≤ R, C ≤ 1500，接下来的R行每行包含C个字符，描述湖面的初始状态，‘·’表示水格，‘ X’表示冰格，‘ L’表示一只白天鹅。

【输出格式】

输出文件仅一行包含一个整数表示两只白天鹅等到相邻那一天所需的天数。

【输入样例】

8 17
...XXXXXX..XX.XXX
....XXXXXXXXX.XXX
...XXXXXXXXXXXX..
..XXXXX.LXXXXXX..
.XXXXXX..XXXXXX..
XXXXXXX...XXXX...
..XXXXX...XXX....
....XXXXX.XXXL...

【输出样例】

2

Hint

30%数据1 ≤ R《400.1 ≤ C《300
100%其中1 ≤ R, C ≤ 1500

题解

怎么说呢，本来和简单的一道题
结果因为一个知识点不熟
然后就没做出来
其实就是两遍DFS 第一遍求出每个点到他的最近的水的距离
然后一边dfs求出起点到终点的过程中的最小值

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
bool map[1505][1505];
int dis[1505][1505];
struct Point
{
    int x, y;
} S, E, Q[20000000];
int R, C;
int movex[5] = {0, 0, 0, 1, -1},
    movey[5] = {0, 1, -1, 0, 0};
bool flag[1505][1505];
void bfs_init()
{
    //memset(flag,0,sizeof(flag));
    int l = 1, r = 0;
    memset(dis, 0x3f, sizeof(dis));
    for (int i = 1; i <= R; i++)
    {
        for (int j = 1; j <= C; j++)
        {
            if (!map[i][j])
            {
                Q[++r] = (Point){i, j};
                dis[i][j] = 0;
            }
        }
    }
    while (l <= r)
    {
        Point k = Q[l++];
        for (int i = 1; i <= 4; i++)
        {
            if (k.x + movex[i] > R || k.x + movex[i] < 1)
                continue;
            if (k.y + movey[i] > C || k.y + movey[i] < 1)
                continue;
            if (dis[k.x + movex[i]][k.y + movey[i]] > dis[k.x][k.y] + 1)
            {
                dis[k.x + movex[i]][k.y + movey[i]] = dis[k.x][k.y] + 1;
                Q[++r] = (Point) { k.x + movex[i], k.y + movey[i] };
            }
        }
    }
}
int d[1505][1505];
 
int SPFA()
{
    memset(d, 0x3f, sizeof(d));
    d[S.x][S.y] = 0;
    int l = 1, r = 0;
    Q[++r] = S;
    //flag[S.x][S.y] = 1;
    while (l <= r)
    {
        Point k = Q[l++];
        //flag[k.x][k.y] = 0;
        for (int i = 1; i <= 4; i++)
        {
            if (k.x + movex[i] > R || k.x + movex[i] < 1)
                continue;
            if (k.y + movey[i] > C || k.y + movey[i] < 1)
                continue;
            if (d[k.x + movex[i]][k.y + movey[i]] > max(d[k.x][k.y], dis[k.x + movex[i]][k.y + movey[i]]))
            {
                d[k.x + movex[i]][k.y + movey[i]] = max(d[k.x][k.y], dis[k.x + movex[i]][k.y + movey[i]]);
                //if (!flag[k.x + movex[i]][k.y + movey[i]])
                //{
                    Q[++r] = (Point){k.x + movex[i], k.y + movey[i]};
                    //flag[k.x + movex[i]][k.y + movey[i]] = 1;
                //}
            }
        }
    }
    return d[E.x][E.y];
}
int main()
{
    //freopen("swan.in", "r", stdin);
    // freopen("swan.out", "w", stdout);
    char c;
    scanf("%d%d", &R, &C);
    bool flag = 0;
    for (int i = 1; i <= R; i++)
    {
        for (int j = 1; j <= C; j++)
        {
            c = getchar();
            while (c != '.' && c != 'X' && c != 'L')
                c = getchar();
            if (c == 'X')
                map[i][j] = 1;
            else if (c == 'L')
            {
                if (flag)
                    E = (Point){i, j};
                else
                {
                    S = (Point){i, j};
                    flag = 1;
                }
            }
        }
    }
    bfs_init();
    printf("%d", SPFA());
    //while (1)
    ;
}

[BZOJ3166]: [Heoi2013] Alo

Sat, 05 Aug 2017 11:18:36 GMT

Description

Welcome to ALO ( Arithmetic and Logistic Online)。这是一个VR MMORPG ，如名字所见，到处充满了数学的谜题。现在你拥有n颗宝石，每颗宝石有一个能量密度，记为ai，这些宝石的能量密度两两不同。现在你可以选取连续的一些宝石（必须多于一个）进行融合，设为 ai, ai+1, …, a j，则融合而成的宝石的能量密度为这些宝石中能量密度的次大值  与其他任意一颗宝石的能量密度按位异或的值，即，设该段宝石能量密度次大值为k，则生成的宝石的能量密度为max{k xor ap | ap ≠ k , i ≤ p ≤ j}。现在你需要知道你怎么选取需要融合的宝石，才能使生成的宝石能量密度最大。

Input

第一行，一个整数 n，表示宝石个数。第二行， n个整数，分别表示a1至an，表示每颗宝石的能量密度，保证对于i ≠ j有 ai ≠ aj。

Output

输出一行一个整数，表示最大能生成的宝石能量密度。

Sample Input

5
9 2 1 4 7

Sample Output

14

HINT

【样例解释】选择区间[1,5]，最大值为 7 xor 9。对于 100%的数据有 1 ≤ n ≤ 50000, 0 ≤ ai ≤ 10^9

题解

如图由左右比他大的值得到了一个区间

我们用Set维护查排名比他大1的就可以了

#include <cstdio>
#include <set>
#include <algorithm>
int n;
const int INF = 1000000000;
const int full = 30;
struct Trie
{
	struct Trie_Node
	{
		Trie_Node *ch[2];
		int s;
		Trie_Node()
		{
			ch[0] = ch[1] = NULL;
			s = 0;
		}
	} * root[100005], *null;
	Trie()
	{
		null = new Trie_Node();
		null->ch[0] = null->ch[1] = null;
		root[0] = new Trie_Node();
		root[0]->ch[1] = root[0]->ch[0] = null;
	}
	Trie_Node *NewNode()
	{
		Trie_Node *rt = new Trie_Node();
		rt->ch[0] = rt->ch[1] = null;
		return rt;
	}
	void copy(Trie_Node *&a, Trie_Node *b)
	{
		if (b == null)
			a = null;
		else
			a = NewNode(), *a = *b;
	}
	void Insert(int x, int cnt)
	{
		copy(root[cnt], root[cnt - 1]);
		Trie_Node *rt1 = root[cnt], *rt2 = root[cnt - 1];
		for (int i = full; i >= 0; i--)
		{
			int k = (x >> i) & 1;
			copy(rt1->ch[k], rt2->ch[k]);
			if (rt1->ch[k] == null)
				rt1->ch[k] = NewNode();
			rt1 = rt1->ch[k], rt2 = rt2->ch[k];
			rt1->s++;
		}
	}
	int Query(int val, int l, int r)
	{
		int res = 0;
		Trie_Node *rt1 = root[r], *rt2 = root[l - 1];
		for (int i = full; i >= 0; i--)
		{
			int next = (val >> i) & 1;
			if (rt1->ch[next ^ 1]->s - rt2->ch[next ^ 1]->s)
			{
				rt1 = rt1->ch[next ^ 1], rt2 = rt2->ch[next ^ 1];
				res |= (1 << i);
			}
			else
			{
				rt1 = rt1->ch[next], rt2 = rt2->ch[next];
			}
		}
		return res;
	}
} root;
struct data
{
	int val, i;
	bool operator < (const data &a)const 
	{
		return val > a.val;
	}
} a[50005];
std::set<int> st;
int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i].val);
		a[i].i = i;
	}
	for (int i = 1; i <= n; ++i)
	{
		root.Insert(a[i].val, i);
	}
	st.insert(-1), st.insert(INF), st.insert(-2), st.insert(INF + 1);
	std::sort(a + 1, a + n + 1);
	st.insert(a[1].i);
	int ans = 0;
	for (int i = 2; i <= n; i++)
	{
		int l = a[i].i, r = a[i].i;
		std::set<int>::iterator T, P;
		P = st.lower_bound(a[i].i);
		T = P;
		r = *T; T++; r = *T - 1;
		l = *--P; P--;l = *P + 1;
		l = std::max(1, l), r = std::min(r, n);
		if (l != r)
		{
			ans = std::max(ans, root.Query(a[i].val, l, r));
		}
		st.insert(a[i].i);
	}
	printf("%d", ans);
}

[BZOJ2432][Noi2011]兔农矩阵乘法+exgcd

Sat, 05 Aug 2017 08:57:32 GMT

Description

农夫栋栋近年收入不景气，正在他发愁如何能多赚点钱时，他听到隔壁的小朋友在讨论兔子繁殖的问题。问题是这样的：第一个月初有一对刚出生的小兔子，经过两个月长大后，这对兔子从第三个月开始，每个月初生一对小兔子。新出生的小兔子生长两个月后又能每个月生出一对小兔子。问第n个月有多少只兔子？  聪明的你可能已经发现，第n个月的兔子数正好是第n个Fibonacci(斐波那契)数。栋栋不懂什么是Fibonacci数，但他也发现了规律：第i+2个月的兔子数等于第i个月的兔子数加上第i+1个月的兔子数。前几个月的兔子数依次为： 1 1 2 3 5 8 13 21 34 … 栋栋发现越到后面兔子数增长的越快，期待养兔子一定能赚大钱，于是栋栋在第一个月初买了一对小兔子开始饲养。每天，栋栋都要给兔子们喂食，兔子们吃食时非常特别，总是每k对兔子围成一圈，最后剩下的不足k对的围成一圈，由于兔子特别害怕孤独，从第三个月开始，如果吃食时围成某一个圈的只有一对兔子，这对兔子就会很快死掉。我们假设死去的总是刚出生的兔子，那么每个月的兔子数仍然是可以计算的。例如，当k=7时，前几个月的兔子数依次为： 1 1 2 3 5 7 12 19 31 49 80 … 给定n，你能帮助栋栋计算第n个月他有多少对兔子么？由于答案可能非常大，你只需要告诉栋栋第n个月的兔子对数除p的余数即可。

Input

输入一行，包含三个正整数n, k, p。

Output

输出一行，包含一个整数，表示栋栋第n个月的兔子对数除p的余数。

Sample Input

6 7 100

Sample Output

7

HINT

$1<=N<=10^18$ $2<=K<=10^6$ $2<=P<=10^9$

题解

暴力75 暴力给的很足可是后面的25分死一样难拿

我们可以以%7为例打一个表如果以减1为0 为分界那么会出现这样的情况

1, 1, 2, 3, 5, 0, 5, 5, 3, 0, 3, 3, 6, 2, 0, 2, 2, 4, 6, 3, 2, 5, 0, 5, 5, 3, 0, 3, 3, 6, 2, 0, ·········

那么我们会发现他用2个性质

我们发现，每段开头必为相同的两数，并且它们恰是上一段的最末一位非0数；由于总共只有k−1种余数，所以不超过k段就会出现循环（如果有的话）。
设开头的数为x 那么这个数列为%k意义下的斐波那契数列

我们发现在最后一个数变为0前
$ x*f[len] \equiv 1 (mod k)$ 那么f[len]为x在模k意义下的逆元
所以，我们可以通过exgcd或者扩展欧拉定理，来快速求出f[len]。如果没有逆元直接斐波那契数列矩阵快速幂过去就可以了

然后我们需要len 其实这个我们可以预处理出来vis
每次查询即可

最后由 $x*f[len-1]$ 得下一段的开头

有一个很强的结论：斐波那契数列在模k意义下一定是以0 1 1……为开头的循环，并且循环节长度<=6*k，所以暴力算vis就可以了

然后我们需要行内的转移矩阵 $$ \begin{bmatrix} 1 & 1 & 0 \ 1 & 0 & 0 \ 0 & 0 & 1 \end{bmatrix} $$

行间的转移矩阵

$$ \begin{bmatrix} 1 & 0 & 0 \ 0 & 1 & 0 \ -1 & 0 & 1 \end{bmatrix} $$

什么你问我代码？我也没打出来啊。。。。。

[NOIP2011] 聪明的质监员

Sat, 05 Aug 2017 08:36:01 GMT

【问题描述】

小 T 是一名质量监督员，最近负责检验一批矿产的质量。这批矿产共有n个矿石，从 1 到n逐一编号，每个矿石都有自己的重量$w_i$以及价值$v_i$。检验矿产的流程是：

给定 m个区间$[L_i,R_i]$；
选出一个参数W；
对于一个区间$[L_i,R_i]$，计算矿石在这个区间上的检验值$Y_i$：

$$ Y_i = \sum_{j}{1}*\sum_{j}{v_j},j \in [L_i,R_i] \and w_j≥W,{j是矿石编号} $$ 这批矿产的检验结果Y为各个区间的检验值之和。即： $$ Y=\sum_{i=1}^{m}{Y_i} $$

若这批矿产的检验结果与所给标准值 S 相差太多，就需要再去检验另一批矿产。小 T 不想费时间去检验另一批矿产，所以他想通过调整参数 W 的值，让检验结果尽可能的靠近标准值 S，即使得S−Y的绝对值最小。请你帮忙求出这个最小值。

【输入】

输入文件 qc.in。第一行包含三个整数n，m，S，分别表示矿石的个数、区间的个数和标准值。接下来的n 行，每行2 个整数，中间用空格隔开，第i+1 行表示i 号矿石的重量wi 和价值vi 。接下来的m 行，表示区间，每行2 个整数，中间用空格隔开，第i+n+1 行表示区间$[L_i,R_i]$的两个端点$L_i$ 和$R_i$。注意：不同区间可能重合或相互重叠。

【输出】

输出文件名为qc.out。输出只有一行，包含一个整数，表示所求的最小值。

【输入输出样例】

qc.in

5 3 15
1 5
2 5
3 5
4 5
5 5
1 5
2 4
3 3

qc.out

10

【输入输出样例说明】

当W 选4 的时候，三个区间上检验值分别为20、5、0，这批矿产的检验结果为25，此时与标准值S 相差最小为10。

【数据范围】

对于10%的数据，有$1≤n，m≤10$；
对于30%的数据，有$1≤n，m≤500$；
对于50%的数据，有$1≤n，m≤5,000$；
对于70%的数据，有$1≤n，m≤10,000$；
对于100%的数据，有$1≤n，m≤200,000,0 < w_i, v_i≤10^6，0 < S≤10^12，1≤L_i≤R_i≤n$。

题解

三分W
$O(n+m)$ 求出Y 然后比较找最近的

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define LL long long
int n, m;
struct data
{
    int w, v;
} a[200005];
struct Data
{
    int l, r;
} Q[200005];
int Sumn[200005];
LL Sumv[200005];
LL check(int w)
{
    Sumn[0] = 0;
    Sumv[0] = 1;
    for (int i = 1; i <= n; i++)
    {
        Sumn[i] = Sumn[i - 1] + (a[i].w > w);
        Sumv[i] = Sumv[i - 1] + (a[i].w > w ? a[i].v : 0);
    }
    LL Y = 0;
    for (int i = 1; i <= m; i++)
    {
        Y += (Sumn[Q[i].r] - Sumn[Q[i].l - 1]) * (Sumv[Q[i].r] - Sumv[Q[i].l - 1]);
    }
    return Y;
}
int main()
{
    freopen("qc.in", "r", stdin);
    freopen("qc.out", "w", stdout);
    LL S;
    scanf("%d%d%lld", &n, &m, &S);
    int Max = 0;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a[i].w, &a[i].v);
        Max = max(Max, a[i].w);
    }
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &Q[i].l, &Q[i].r);
    }
    LL l = 0, r = Max;
    LL ans = 0x3fffffffffffffffLL;
    while (l < r)
    {
        LL mid = l + r >> 1;
        LL t = check(mid);
        if (t < S)
        {
            ans = min(ans, abs(t - S));
            r = mid;
        }
        else
        {
            ans = min(ans, abs(t - S));
            l = mid + 1;
        }
    }
    printf("%lld", ans);

    //while (1);
}

[BZOJ 1124][POI 2008] 枪战 Maf

Thu, 03 Aug 2017 08:37:31 GMT

Description

有n个人，每个人手里有一把手枪。一开始所有人都选定一个人瞄准（有可能瞄准自己）。然后他们按某个顺序开枪，且任意时刻只有一个人开枪。因此，对于不同的开枪顺序，最后死的人也不同。

Input

输入n人数<1000000 每个人的aim

Output

你要求最后死亡数目的最小和最大可能

Sample Input

8
2 3 2 2 6 7 8 5

Sample Output

3 5

我也不会啊

树DPTH_Hugh
liu_runda

贴代码

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
int a[1000005], Maxn, t, Min, Max;
int times[1000005];
bool die[1000005], nodie[1000005];
int Q[1000005];
int main()
{
    //freopen("maf.in", "r", stdin);
    //freopen("maf.out", "w", stdout);
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        times[a[i]]++;
    }
    //Q.resize(1000001);
    for (int i = 1; i <= n; i++)
    {
        if (!times[i])
        {
            Max++;
            Q[++Min] = i;
        }
    }
    //printf("%d\n",Max);

    //for (vector<int>::iterator it = Q.begin(); it != Q.end(); it++)
    for (int i = 1; i <= Min; i++)
    {
        //printf("%d---------%d=======\n",it-Q.begin(),*it);
        int k = a[Q[i]];
        if (die[k])
            continue;
        die[k] = 1;
        nodie[a[k]] = 1;
        --times[a[k]];
        if (!times[a[k]])
        {
            Q[++Min]=a[k]; 
        }
    }
    int sum;
    bool All_NoDied;
    for (int i = 1; i <= n; i++)
    {
        if (times[i] && !die[i])
        {
            sum = 0;
            All_NoDied = 0;
            for (int j = i; !die[j]; j = a[j])
            {
                die[j] = 1;
                sum++;
                All_NoDied |= nodie[j];
            }
            if (!All_NoDied && sum > 1)
                Max++;
            Min += sum / 2;
        }
    }
    printf("%d %d\n", n - Min, n - Max);
}

[BZOJ 1647][USACO 2007 Open] Fliptile 翻格子游戏

Thu, 03 Aug 2017 08:36:56 GMT

Description

Farmer John knows that an intellectually satisfied cow is a happy cow who will give more milk. He has arranged a brainy activity for cows in which they manipulate an M x N grid (1 <= M <= 15; 1 <= N <= 15) of square tiles, each of which is colored black on one side and white on the other side. As one would guess, when a single white tile is flipped, it changes to black;  when a single black tile is flipped, it changes to white. The cows are rewarded when they flip the tiles so that each tile has the white side face up. However, the cows have rather large hooves and when they try to flip a certain tile, they also flip all the adjacent tiles (tiles that share a full edge with the flipped tile). Since the flips are tiring, the cows want to minimize the number of flips they have to make. Help the cows determine the minimum number of flips required, and the locations to flip to achieve that minimum. If there are multiple ways to achieve the task with the minimum amount of flips, return the one with the least lexicographical ordering in the output when considered as a string. If the task is impossible, print one line with the word "IMPOSSIBLE".

约翰知道，那些高智力又快乐的奶牛产奶量特别高．所以他做了一个翻瓦片的益智游戏来娱乐奶牛．在一个M×N(1≤M，N≤15)的骨架上，每一个格子里都有一个可以翻转的瓦片．瓦片的一面是黑色的，而另一面是白色的．对一个瓦片进行翻转，可以使黑变白，也可以使白变黑．然而，奶牛们的蹄子是如此的巨大而且笨拙，所以她们翻转一个瓦片的时候，与之有公共边的相邻瓦片也都被翻转了．那么，这些奶牛们最少需要多少次翻转，使所有的瓦片都变成白面向上呢？如杲可以做到，输出字典序最小的结果（将结果当成字符串处理）．如果不能做到，输出“IMPOSSIBLE”．

Input

Line 1: Two space-separated integers: M and N
Lines 2..M+1: Line i+1 describes the colors (left to right) of row i of the grid with N space-separated integers which are 1 for black and 0 for white

第1行输入M和N，之后M行N列，输入游戏开始时的瓦片状态．0表示白面向上，1表示黑面向上．

Output

Lines 1..M: Each line contains N space-separated integers, each specifying how many times to flip that particular location.

输出M行，每行N个用空格隔开的整数，表示对应的格子进行了多少次翻转．

Sample Input

4 4
1 0 0 1
0 1 1 0
0 1 1 0
1 0 0 1

Sample Output

0 0 0 0
1 0 0 1
1 0 0 1
0 0 0 0

OUTPUT DETAILS:

After flipping at row 2 column 1, the board will look like:
0 0 0 1
1 0 1 0
1 1 1 0
1 0 0 1

After flipping at row 2 column 4, the board will look like:
0 0 0 0
1 0 0 1
1 1 1 1
1 0 0 1

After flipping at row 3 column 1, the board will look like:
0 0 0 0
0 0 0 1
0 0 1 1
0 0 0 1

After flipping at row 3 column 4, the board will look like:
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

Another solution might be:
0 1 1 0
0 0 0 0
0 0 0 0
0 1 1 0
but this solution is lexicographically higher than the solution above.

题解

枚举第一行就可以了
然后往下跑

#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
int n, m;
int b[17][17], a[17][17], op[17][17];
inline void DoChange(int x)
{
    for (int j = 1; j <= n; j++)
    {
        if (op[x][j])
        {
            a[x - 1][j] ^= 1;
            a[x][j - 1] ^= 1;
            a[x][j + 1] ^= 1;
            a[x + 1][j] ^= 1;
        }
    }
}
inline bool ok()
{
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (a[i][j] == 1)
                return 0;
        }
    }
    return 1;
}
inline void print()
{
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            printf("%d ", op[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    //freopen("fliptile.in", "r", stdin);
    //freopen("fliptile.out", "w", stdout);
    scanf("%d%d", &m, &n);
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
        {
            scanf("%d", &b[i][j]);
        }
    int N = (1 << n) - 1;
    for (int i = 0; i <= N; i++)
    {
        memcpy(a, b, sizeof(a));
        memset(op, 0, sizeof(op));
        for (int j = 1; j <= n; j++)
        {
            if (i & (1 << (j - 1)))
            {
                op[1][j] = 1;
                a[1 - 1][j] ^= 1;
                a[1][j - 1] ^= 1;
                a[1][j] ^= 1;
                a[1][j + 1] ^= 1;
                a[1 + 1][j] ^= 1;
            }
        }
        for (int j = 1; j < m; j++)
        {
            for (int k = 1; k <= n; k++)
            {
                if (a[j][k])
                {
                    op[j + 1][k] = 1;
                    a[j][k] ^= 1;
                    a[j + 1][k] ^= 1;
                    a[j + 1][k - 1] ^= 1;
                    a[j + 1][k + 1] ^= 1;
                    a[j + 2][k] ^= 1;
                }
            }
        }
        if (ok())
        {
            print();
            //while (1);
            exit(0);
        }
    }
    printf("IMPOSSIBLE\n");
}

[BZOJ 1592] Making The Grade路面修整

Thu, 03 Aug 2017 08:24:30 GMT

Description

FJ打算好好修一下农场中某条凹凸不平的土路。按奶牛们的要求，修好后的路面高度应当单调上升或单调下降，也就是说，高度上升与高度下降的路段不能同时出现在修好的路中。整条路被分成了N段，N个整数A_1, ... , A_N (1 <= N <= 2,000)依次描述了每一段路的高度(0 <= A_i <= 1,000,000,000)。FJ希望找到一个恰好含N个元素的不上升或不下降序列B_1, ... , B_N，作为修过的路中每个路段的高度。由于将每一段路垫高或挖低一个单位的花费相同，修路的总支出可以表示为：$ |A_1 - B_1| + |A_2 - B_2| + ... + |A_N - B_N| $请你计算一下，FJ在这项工程上的最小支出是多少。FJ向你保证，这个支出不会超过2^31-1。

Input

第1行: 输入1个整数：N * 第2..N+1行: 第i+1行为1个整数：A_i

Output

第1行: 输出1个正整数，表示FJ把路修成高度不上升或高度不下降的最小花费

Sample Input

7
1
3
2
4
5
3
9

Sample Output

3

HINT

FJ将第一个高度为3的路段的高度减少为2，将第二个高度为3的路段的高度增加到5，总花费为|2-3|+|5-3| = 3，并且各路段的高度为一个不下降序列 1,2,2,4,5,5,9。

题解

方程 $f_{i,j}=min( f_{i,j-1}, f_{i-1,j}+ \left | a_i - b_j \right | ) $
不知道为什么只正向能过

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
int a[2005], n, size;
int f[2005][2005];
int Hash[2005];
inline void Hash_init()
{
    sort(Hash + 1, Hash + n + 1);
    size = unique(Hash + 1, Hash + n + 1) - Hash - 1;
}
int main()
{
    // freopen("grading.in","r",stdin);
    // freopen("grading.out","w",stdout);
    scanf("%d\n", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        Hash[i] = a[i];
    }
    Hash_init();
    int minn = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++)
    {   
        minn = 0x3f3f3f3f;
        for (int j = 1; j <= size; j++)
        {
            minn = min(minn, f[i - 1][j]);
            f[i][j] = minn +abs(Hash[j] - a[i]);
        }
    }
    int ans = 0x3f3f3f3f;
    for (int i = 1; i <= size; i++)
        ans = min(ans, f[n][i]);
    memset(f,0,sizeof(f));
    // for (int i = n; i >= 1; i++)
    // {   
    //     minn = 0x3f3f3f3f;
    //     for (int j = 1; j <= size; j++)
    //     {
    //         minn = min(minn, f[i + 1][j]);
    //         f[i][j] = minn +abs(Hash[j] - a[i]);
    //     }
    // }
    // for (int i = 1; i <= size; i++)
    //     ans = min(ans, f[1][i]);
    printf("%d\n", ans);
}

[BZOJ 4832] [Lydsy2017年4月月赛]抵制克苏恩

Thu, 03 Aug 2017 08:14:26 GMT

Description

小Q同学现在沉迷炉石传说不能自拔。他发现一张名为克苏恩的牌很不公平。如果你不玩炉石传说，不必担心，小Q 同学会告诉你所有相关的细节。炉石传说是这样的一个游戏，每个玩家拥有一个 30 点血量的英雄，并且可以用牌召唤至多 7 个随从帮助玩家攻击对手，其中每个随从也拥有自己的血量和攻击力。小Q同学有很多次游戏失败都是因为对手使用了克苏恩这张牌，所以他想找到一些方法来抵御克苏恩。他去求助职业炉石传说玩家椎名真白，真白  告诉他使用奴隶主这张牌就可以啦。如果你不明白我上面在说什么，不必担心，小Q同学会告诉你他想让你做什么。现在小Q同学会给出克苏恩的攻击力是 K ，表示克苏恩会攻击 K 次，每次会从对方场上的英雄和随从中随机选择一个并对其产生 1 点伤害。现在对方有一名克苏恩，你有一些奴隶主作为随从，每名奴隶主的血量是给定的。如果克苏恩攻击了你的一名奴隶主，那么这名奴隶主的血量会减少 1 点，当其血量小于等于 0 时会死亡，如果受到攻击后不死亡，并且你的随从数量没有达到 7 ，这名奴隶主会召唤一个拥有 3 点血量的新奴隶主作为你的随从；如果克苏恩攻击了你的英雄，你的英雄会记录受到 1 点伤害。你应该注意到了，每当克苏恩进行一次攻击，你场上的随从可能发生很大的变化。小Q同学为你假设了克苏恩的攻击力，你场上分别有 1 点、 2 点、 3 点血量的奴隶主数量，你可以计算出你的英雄受到的总伤害的期望值是多少吗？

Input

输入包含多局游戏。第一行包含一个整数 T (T<100) ，表示游戏的局数。每局游戏仅占一行，包含四个非负整数 K, A, B 和 C ，表示克苏恩的攻击力是 K ，你有 A 个 1 点血量的奴隶主， B 个 2 点血量的奴隶主， C 个 3 点血量的奴隶主。保证 K 是小于 50 的正数， A+B+C 不超过 7 。

Output

对于每局游戏，输出一个数字表示总伤害的期望值，保留两位小数。

Sample Input

1
1 1 1 1

Sample Output

0.25

题解

简单的基础概率DP

#include <cstdio>
#include <cstring>
using namespace std;
double f[55][8][8][8];
int main(int argc, char const *argv[])
{
    int T, a, b, c, k;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d%d%d", &k, &a, &b, &c);
        memset(f, 0, sizeof(f));
        f[1][a][b][c] = 1;
        double ans = 0;
        for (int i = 1; i <= k; i++)
        {
            for (int j = 0; j <= 7; j++)
                for (int l = 0; l <= 7; l++)
                    for (int m = 0; m <= 7; m++)
                    {
                        if (l + j + m <= 7)
                        {
                            if (j > 0)
                                f[i + 1][j - 1][l][m] += f[i][j][l][m] * j * 1.0 / (l + j + m + 1);
                            if (l > 0)
                            {
                                if (l + j + m <= 6)
                                    f[i + 1][j + 1][l - 1][m + 1] += f[i][j][l][m] * l * 1.0 / (l + j + m + 1);
                                else
                                    f[i + 1][j + 1][l - 1][m] += f[i][j][l][m] * l * 1.0 / (l + j + m + 1);
                            }
                            if (m > 0)
                            {
                                if (l + j + m <= 6)
                                    f[i + 1][j][l + 1][m] += f[i][j][l][m] * m * 1.0 / (l + j + m + 1);
                                else
                                    f[i + 1][j][l + 1][m - 1] += f[i][j][l][m] * m * 1.0 / (l + j + m + 1);
                            }
                            f[i + 1][j][l][m] += f[i][j][l][m] * 1.0 / (l + j + m + 1);
                            ans += f[i][j][l][m] * 1.0 / (l + j + m + 1);
                        }
                    }
        }
        printf("%.2lf\n", ans);
    }
    //while (1)
        ;
    return 0;
}

[BZOJ 3829][POI2014] FarmCraft

Thu, 03 Aug 2017 08:14:26 GMT

Description

In a village called Byteville, there are houses connected with N-1 roads. For each pair of houses, there is a unique way to get from one to another. The houses are numbered from 1 to . The house no. 1 belongs to the village administrator Byteasar. As part of enabling modern technologies for rural areas framework, computers have been delivered to Byteasar's house. Every house is to be supplied with a computer, and it is Byteasar's task to distribute them. The citizens of Byteville have already agreed to play the most recent version of FarmCraft (the game) as soon as they have their computers.  Byteasar has loaded all the computers on his pickup truck and is about to set out to deliver the goods. He has just the right amount of gasoline to drive each road twice. In each house, Byteasar leaves one computer, and immediately continues on his route. In each house, as soon as house dwellers get their computer, they turn it on and install FarmCraft. The time it takes to install and set up the game very much depends on one's tech savviness, which is fortunately known for each household. After he delivers all the computers, Byteasar will come back to his house and install the game on his computer. The travel time along each road linking two houses is exactly 1 minute, and (due to citizens' eagerness to play) the time to unload a computer is negligible. Help Byteasar in determining a delivery order that allows all Byteville's citizens (including Byteasar) to start playing together as soon as possible. In other words, find an order that minimizes the time when everyone has FarmCraft installed. mhy住在一棵有n个点的树的1号结点上，每个结点上都有一个妹子。 mhy从自己家出发，去给每一个妹子都送一台电脑，每个妹子拿到电脑后就会开始安装zhx牌杀毒软件，第i个妹子安装时间为Ci。树上的每条边mhy能且仅能走两次，每次耗费1单位时间。mhy送完所有电脑后会回自己家里然后开始装zhx牌杀毒软件。卸货和装电脑是不需要时间的。求所有妹子和mhy都装好zhx牌杀毒软件的最短时间。

Input

The first line of the standard input contains a single integer N(2<=N<=5 00 000) that gives the number of houses in Byteville. The second line contains N integers C1,C2…Cn(1<=Ci<=10^9), separated by single spaces; Ci is the installation time (in minutes) for the dwellers of house no. i. The next N-1 lines specify the roads linking the houses. Each such line contains two positive integers a and b(1<=a<b<=N) , separated by a single space. These indicate that there is a direct road between the houses no. a and b.

Output

The first and only line of the standard output should contain a single integer: the (minimum) number of minutes after which all citizens will be able to play FarmCraft together.

Sample Input

6
1 8 9 6 3 2
1 3
2 3
3 4
4 5
4 6

Sample Output

11

HINT

Explanation: Byteasar should deliver the computers to the houses in the following order: 3, 2, 4, 5, 6, and 1. The game will be installed after 11, 10, 10, 10, 8, and 9 minutes respectively, in the house number order. Thus everyone can play after 11 minutes.

If Byteasar delivered the game in the following order: 3, 4, 5, 6, 2, and 1, then the game would be installed after: 11, 16, 10, 8, 6, and 7 minutes respectively. Hence, everyone could play only after 16 minutes,

题解

直接搞
记录一个值为总时间减遍历时间

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <functional>
using namespace std;
struct edge
{
    int END, next;
} v[1000005];
int w[500005], first[500005], p;
void add(int a, int b)
{
    v[p].END = b;
    v[p].next = first[a];
    first[a] = p++;
}
int f[500005];
int dfs(int x, int fa)
{
    int t = 0;
    for (int i = first[x]; i != -1; i = v[i].next)
    {
        if (v[i].END != fa)
        {
            f[v[i].END] = dfs(v[i].END, x);
            t += f[v[i].END] + 2;
        }
    }
    return t;
}
int t[500005];
int comp(const int &a, const int &b)
{
    return t[a] > t[b];
}
void DP(int x, int fa)
{
    vector<int> re;
    for (int i = first[x]; i != -1; i = v[i].next)
        if (v[i].END != fa)
        {
            DP(v[i].END, x);
            re.push_back(v[i].END);
        }
    sort(re.begin(), re.end(), comp);
    if (x != 1)
        t[x] = w[x] - f[x];
    int now = f[x];
    for (int i = 0; i < re.size(); i++)
    {
        now -= (f[re[i]] + 2);
        t[x] = max(t[x], t[re[i]] - now - 1);
    }
    t[x] = max(t[x], 0);
}
int main()
{
    freopen("farmcraft.in", "r", stdin);
    freopen("farmcraft.out", "w", stdout);
    //memset(f, -1, sizeof(f));
    memset(first, -1, sizeof(first));
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &w[i]);
    }
    int a, b;
    for (int i = 1; i < n; i++)
    {
        scanf("%d%d", &a, &b);
        add(a, b);
        add(b, a);
    }
    f[1] = dfs(1, 0);
    //for (int i = 1; i <= n; i++)
    // printf("%d ", f[i]);
    //printf("\n======================\n");
    DP(1, 0);
    //while(1);
    printf("%d\n", f[1] + max(w[1], t[1]));
}

[NOIP2015] 斗地主

Thu, 03 Aug 2017 07:45:19 GMT

Description

牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3<4<5<6<7<8<9<10<J<Q<K<A<2<小王<大王，而花色并不对牌的大小产生影响。每一局游戏中，一副手牌由n张牌组成。游戏者每次可以根据规定的牌型进行出牌，首先打光自己的手牌一方取得游戏的胜利。现在，牛牛只想知道，对于自己的若干组手牌，分别最少需要多少次出牌可以将它们打光。请你帮他解决这个问题。需要注意的是，本题中游戏者每次可以出手的牌型与一般的斗地主相似而略有不同。具体规则如下：

Input

第一行包含用空格隔开的2个正整数T,N，表示手牌的组数以及每组手牌的张数。

接下来T组数据，每组数据N行，每行一个非负整数对Ai,Bi，表示一张牌，其中Ai表示牌的数码,Bi表示牌的花色，中间用空格隔开。特别的，我们用1来表示数码A，11表示数码J，12表示数码Q，13表示数码K；黑桃、红心、梅花、方片分别用1-4来表示；小王的表示方法为01，大王的表示方法为02。

Output

共T行，每行一个整数，表示打光第T组手牌的最少次数。

Sample Input

1 8
7 4
8 4
9 1
10 4
11 1
5 1
1 4
1 1

Sample Output

3

HINT

共有1组手牌，包含8张牌：方片7，方片8，黑桃9，方片10，黑桃J，黑桃5，方片A以及黑桃A。可以通过打单顺子（方片7，方片8，黑桃9，方片10，黑桃J），单张牌（黑桃5）以及对子牌（黑桃A以及方片A）在3次内打光。

题解

搜吧

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
struct data
{
    int t, l, r;
};
int cnt[16];
int backcnt[16];
vector<data> s;
int times[5];
int Query()
{
    memcpy(backcnt, cnt, sizeof(backcnt));
    memset(times, 0, sizeof(times));
    // int ans = s.size();
    // for (int i = 0; i < s.size(); i++)
    // {
    //     for (int j = s[i].l; j <= s[i].r; j++)
    //         backcnt[j] -= s[i].t;
    // }
    int ans = 0;
    for (int i = 1; i <= 14; i++)
    {
        times[backcnt[i]]++;
    }
    while (times[4] > 0 && times[2] > 1)
    {
        times[4]--;
        times[2] -= 2;
        ans++;
    }
    while (times[4] > 0 && times[1] > 1)
    {
        times[4]--;
        times[1] -= 2;
        ans++;
    }
    while (times[4] > 0 && times[2] > 0)
    {
        times[4]--;
        times[2]--;
        ans++;
    }
    while (times[3] > 0 && times[2] > 0)
    {
        times[3]--;
        times[2]--;
        ans++;
    }
    while (times[3] > 0 && times[1] > 0)
    {
        times[3]--;
        times[1]--;
        ans++;
    }
    while (times[4] > 0)
    {
        times[4]--;
        ans++;
    }
    while (times[3] > 0)
    {
        times[3]--;
        ans++;
    }
    while (times[2] > 0)
    {
        times[2]--;
        ans++;
    }
    while (times[1] > 0)
    {
        times[1]--;
        ans++;
    }
    return ans;
}
int DFS()
{
    //int ans = 0x3f3f3f3f;
    int ans = Query();
    for (int i = 1; i <= 12; i++)
    {
        if (cnt[i])
        {
            for (int j = i + 1; j <= 12; j++)
            {
                if (!cnt[j])
                    break;
                if (j - i + 1 >= 5)
                {
                    //s.push_back((data){1, i, j});
                    for (int k = i; k <= j; k++)
                        cnt[k] -= 1;
                    ans = min(ans, DFS()+1);
                    for (int k = i; k <= j; k++)
                        cnt[k] += 1;
                    //ans = min(ans, Query(1));
                    //s.pop_back();
                }
            }
        }
        if (cnt[i] >= 2)
        {
            for (int j = i + 1; j <= 12; j++)
            {
                if (cnt[j] < 2)
                    break;
                if (j - i + 1 >= 3)
                {
                    for (int k = i; k <= j; k++)
                        cnt[k] -= 2;
                    ans = min(ans, DFS()+1);
                    for (int k = i; k <= j; k++)
                        cnt[k] += 2;
                    // s.push_back((data){2, i, j});
                    // ans = min(ans, DFS(j + 1));
                    // ans = min(ans, Query(1));
                    // s.pop_back();
                }
            }
        }
        if (cnt[i] >= 3)
        {
            for (int j = i + 1; j <= 12; j++)
            {
                if (cnt[j] < 3)
                    break;
                if (j - i + 1 >= 2)
                {
                    for (int k = i; k <= j; k++)
                        cnt[k] -= 3;
                    ans = min(ans, DFS()+1);
                    for (int k = i; k <= j; k++)
                        cnt[k] += 3;
                    // s.push_back((data){3, i, j});
                    // ans = min(ans, DFS(j + 1));
                    // ans = min(ans, Query(1));
                    // s.pop_back();
                }
            }
        }
    }
    //ans = min(ans, Query(1));
    return ans;
}
int main(int argc, char const *argv[])
{
    freopen("landlords.in", "r", stdin);
    freopen("landlords.out", "w", stdout);
    int T, n;
    //int C = 1;
    scanf("%d%d", &T, &n);
    while (T--)
    {
        int a, b;
        memset(cnt, 0, sizeof(cnt));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d", &a, &b);
            if (a)
                if ((a + 11) % 13)
                    cnt[(a + 11) % 13]++;
                else
                    cnt[13]++;
            else
                cnt[14]++;
        }
        s.clear();
        printf("%d\n", DFS());
    }

    return 0;
}

BZOJ 2588 [Spoj 10628] Count on a tree

Thu, 03 Aug 2017 06:24:05 GMT

Description

给定一棵N个节点的树，每个点有一个权值，对于M个询问(u,v,k)，你需要回答u xor lastans和v这两个节点间第K小的点权。其中lastans是上一个询问的答案，初始为0，即第一个询问的u是明文。

Input

第一行两个整数N,M。第二行有N个整数，其中第i个整数表示点i的权值。后面N-1行每行两个整数(x,y)，表示点x到点y有一条边。最后M行每行两个整数(u,v,k)，表示一组询问。

Output

M行，表示每个询问的答案。最后一个询问不输出换行符

Sample Input

8 5
105 2 9 3 8 5 7 7
1 2
1 3
1 4
3 5
3 6
3 7
4 8
2 5 1
0 5 2
10 5 3
11 5 4
110 8 2

Sample Output

2
8
9
105
7

题解

简单来说可以每个节点复制他父亲的节点在新版本中插入自己
然后两个点之间的k小值就是a-lca + b-fa[lca];

#include <cstdio>
#include <queue>
#include <climits>
#include <algorithm>
using namespace std;
struct Seg_Node *null;
struct Seg_Node
{
    Seg_Node *ch[2];
    int cnt;
    //#define cnt(_) ((_) ? (_)->cnt : 0)
    Seg_Node(Seg_Node *l, Seg_Node *r)
    {
        ch[0] = l, ch[1] = r;
        cnt = ch[0]->cnt + ch[1]->cnt;
    }
    Seg_Node(Seg_Node *l, Seg_Node *r, int _cnt)
    {
        ch[0] = l, ch[1] = r;
        cnt = _cnt;
    }
    Seg_Node *insert(int l, int r, int x)
    {
        if (l == r)
            return new Seg_Node(null, null, cnt + 1);
        else
        {
            int m = l + (r - l) / 2;
            if (x <= m)
                return new Seg_Node(ch[0]->insert(l, m, x), ch[1]);
            else
                return new Seg_Node(ch[0], ch[1]->insert(m + 1, r, x));
        }
    }
};
struct Node
{
    vector<Node *> ch;
    Node *fa;
    int dep, w;
    bool vis;
    Seg_Node *Seg;
} v[100005];
 
void addedge(int a, int b)
{
    v[a].ch.push_back(&v[b]);
    v[b].ch.push_back(&v[a]);
}
void init()
{
    null = new Seg_Node(NULL, NULL, 0);
    null->ch[0] = null->ch[1] = null;
}
int n, f[100005][20], logn;
void build()
{
    v[0].vis = 1;
    v[0].Seg = null;
    queue<Node *> Q;
    Q.push(&v[1]);
    v[1].vis = 1;
    v[1].dep = 1;
    v[1].fa = &v[0];
    while (!Q.empty())
    {
        Node *e = Q.front();
        Q.pop();
        e->Seg = e->fa->Seg->insert(0, INT_MAX, e->w);
        for (Node **p = &e->ch.front(), *u = *p; p <= &e->ch.back(); u = *++p)
        {
            if (!u->vis)
            {
                u->vis = 1;
                u->dep = e->dep + 1;
                u->fa = e;
                Q.push(u);
            }
        }
    }
    while ((1 << (logn + 1)) <= n)
        logn++;
    f[1][0] = 1;
    for (int i = 2; i <= n; i++)
        f[i][0] = v[i].fa - v;
    for (int j = 1; j <= logn; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            f[i][j] = f[f[i][j - 1]][j - 1];
        }
    }
}
int lca(int s, int e)
{
    if (v[s].dep < v[e].dep)
        swap(s, e);
    if (v[s].dep > v[e].dep)
    {
        for (int i = logn; i >= 0; i--)
        {
            if (v[f[s][i]].dep >= v[e].dep)
                s = f[s][i];
        }
    }
    if (s != e)
    {
        for (int i = logn; i >= 0; i--)
        {
            if (f[s][i] != f[e][i])
            {
                s = f[s][i];
                e = f[e][i];
            }
        }
        return f[s][0];
    }
    return s;
}
int Query(int s, int e, int k)
{
    int p = lca(s, e);
    Seg_Node *Su = v[s].Seg, *Sv = v[e].Seg, *Sp = v[p].Seg, *Sf = v[p].fa->Seg;
    int l = 0, r = INT_MAX;
    while (l < r)
    {
        int m = l + (r - l) / 2;
        int S = Su->ch[0]->cnt + Sv->ch[0]->cnt - Sp->ch[0]->cnt - Sf->ch[0]->cnt;
        if (k > S)
        {
            k -= S;
            l = m + 1;
            Su = Su->ch[1];
            Sv = Sv->ch[1];
            Sp = Sp->ch[1];
            Sf = Sf->ch[1];
        }
        else
        {
            r = m;
            Su = Su->ch[0];
            Sv = Sv->ch[0];
            Sp = Sp->ch[0];
            Sf = Sf->ch[0];
        }
    }
    return l;
}
int main()
{
    int m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        scanf("%d", &v[i].w);
    for (int i = 1; i <= n - 1; i++)
    {
        int s, e;
        scanf("%d%d", &s, &e);
        addedge(s, e);
    }
    init();
    build();
    int ans = 0;
    while (m--)
    {
        int s, e, k;
        scanf("%d%d%d", &s, &e, &k);
        s ^= ans;
        printf(m ? "%d\n" : "%d", ans = Query(s, e, k));
    }
}

[BZOJ 1409] Password

Thu, 03 Aug 2017 06:24:05 GMT

Description

Rivest是密码学专家。近日他正在研究一种数列E = {E[1],E[2],……,E[n]}，且E[1] = E[2] = p（p为一个质数），E[i] = E[i-2]*E[i-1] （若2<i<=n）。

例如{2,2,4,8,32,256,8192,……}就是p = 2的数列。在此基础上他又设计了一种加密算法，该算法可以通过一个密钥q (q < p)将一个正整数n加密成另外一个正整数d，计算公式为：d = E[n] mod q。现在Rivest想对一组数据进行加密，但他对程序设计不太感兴趣，请你帮助他设计一个数据加密程序。

Input

第一行读入m，p。其中m表示数据个数，p用来生成数列E。以下有m行，每行有2个整数n，q。n为待加密数据，q为密钥。数据范围: 0 < p n< 2^31 0 < q < p 0 < m <= 5000。

Output

将加密后的数据按顺序输出到文件第i行输出第i个加密后的数据。

Sample Input

输入样例1
2 7
4 5
4 6
输入样例2
4 7
2 4
7 1
6 5
9 3

Sample Output

输出样例1
3
1
输出样例2
3
0
1
1

题解

设斐波那契数列的第i项为$F(i)$
斐波那契数列
可以发现$E[i]=p^F(i)$
所以我们的任务变为了求$F(i)$然后矩阵快速幂
$$ \begin{bmatrix} 1 & 1 \ 1 & 0 \ \end{bmatrix} $$ 最后乘上$ \begin{bmatrix} 1 \ 1 \ \end{bmatrix} $ 就可以了

然后由出现了一个问题
我们需要取膜（雾）
要知道 $ a^b%p!=a^{b%p}%p $ 所以我们需要欧拉定理
$$ a^{\phi{n}} \equiv 1 (mod n) $$ 然后易得
$$ a^{b%\phi{p}} \equiv a^b (mod p) $$
使用条件是 a与p 互质

然后就可以了筛出素数 $ \sqrt{n} $求$\phi{n}$就行了

#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
bool isnprime[1000005];
int prime[200005], Idx;
void Get_Prime()
{
    isnprime[1] = 1;
    for (int i = 2; i <= 1000000; i++)
    {
        if (!isnprime[i])
        {
            prime[++Idx] = i;
        }
        for (int j = 1; j <= Idx; j++)
        {
            if (prime[j] * i > 1000000)
                break;
            isnprime[i * prime[j]] = 1;
            if (i % prime[j] == 0)
                break;
        }
    }
}
long long Get_Phi(long long x)
{
    if (x == 1)
        return 0;
    int i = 1;
    int Sq = sqrt(x);
    long long ans = x;
    while (x != 1)
    {
        if (prime[i] > Sq)
        {
            ans = ans - ans / x;
            break;
        }
        if (x % prime[i] == 0)
        {
            ans = ans - ans / prime[i];
            while (x % prime[i] == 0)
                x /= prime[i];
        }
        ++i;
    }
    return ans;
}
long long phi;
class Matrix
{
  public:
    int n, m;
    long long a[3][3];
    Matrix(int n1, int m1)
    {
        n = n1, m = m1;
        memset(a, 0, sizeof(a));
    }
    Matrix operator*(const Matrix &A)
    {
        Matrix ans(n, A.m);
        for (int i = 1; i <= n; i++)
            for (int k = 1; k <= A.m; k++)
            {
                for (int j = 1; j <= m; j++)
                    ans.a[i][k] += a[i][j] * A.a[j][k];
                if (ans.a[i][k] >= phi)
                    ans.a[i][k] = ans.a[i][k] % phi/* + phi*/;
            }
        return ans;
    }
    Matrix operator^(const long long &b)
    {
        long long k = b;
        Matrix ans(n, m);
        for (int i = 1; i <= n; i++)
        {
            ans.a[i][i] = 1;
        }
        Matrix A = *this;
        while (k)
        {
            if (k & 1)
                ans = ans * A;
            k >>= 1;
            A = A * A;
        }
        return ans;
    }
};
long long pow_mod(long long a, long long b, long long mod)
{
    long long ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % mod;
        b >>= 1;
        a = a * a % mod;
    }
    return ans;
}
int main()
{
    freopen("password.in", "r", stdin);
    freopen("password.out", "w", stdout);
    long long m, p;
    Get_Prime();
    Matrix O(2, 2);
    O.a[1][1] = O.a[1][2] = O.a[2][1] = 1;
    Matrix L(2, 1);
    L.a[1][1] = 1;
    scanf("%lld%lld", &m, &p);
    while (m--)
    {
        long long n, q;
        scanf("%lld%lld", &n, &q);
        if (q == 1)
        {
            printf("0\n");
            continue;
        }
        int t = p - q;
        if (t == 1)
        {
            printf("1\n");
            continue;
        }
        phi = Get_Phi(q);
        printf("%lld\n", pow_mod(p, ((O ^ n) * L).a[2][1], q));
    }
}

BZOJ 1901 [Zju2112] Dynamic Rankings

Thu, 03 Aug 2017 05:38:04 GMT

Description

给定一个含有n个数的序列a[1],a[2],a[3]……a[n]，程序必须回答这样的询问：对于给定的i,j,k，在a[i],a[i+1 ],a[i+2]……a[j]中第k小的数是多少(1≤k≤j-i+1)，并且，你可以改变一些a[i]的值，改变后，程序还能针对改变后的a继续回答上面的问题。

Input

第一行一个数字N，代表测试组数对于每组数据第一行有两个正整数n(1≤n≤10000)，m(1≤m≤10000)。分别表示序列的长度和指令的个数。第二行有n个数，表示a[1],a[2]……a[n]，这些数都小于10^9。接下来的m行描述每条指令每行的格式是下面两种格式中的一种。 Q i j k 或者 C i t Q i j k （i,j,k是数字，1≤i≤j≤n, 1≤k≤j-i+1）表示询问指令，询问a[i]，a[i+1]……a[j]中第k小的数。 C i t (1≤i≤n，0≤t≤10^9)表示把a[i]改变成为t

Output

对于每一次询问，你都需要输出他的答案，每一个输出占单独的一行。

Sample Input

1
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6

题解

简单的来说就是待修改的区间k小值

我们用让线段树外面套一层树状数组就可以修改了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
const int N = 1000000000;
#define lowbit(_) ((_) & (-_))
struct Seg_Node
{
    Seg_Node *ch[2];
    int sum, l, r;
    Seg_Node(int L, int R)
    {
        sum = 0, l = L, r = R;
        ch[1] = ch[0] = NULL;
    }
#define sum(_) ((_) ? (_)->sum : 0)
    void Pushup()
    {
        sum = sum(ch[0]) + sum(ch[1]);
    }
} * root[50005];
int a[50005];
int n;
void Insert(Seg_Node *rt, int num)
{
    if (rt->l == rt->r)
    {
        rt->sum++;
        return;
    }
    int m = rt->l + rt->r >> 1;
    if (num <= m)
    {
        if (!rt->ch[0])
            rt->ch[0] = new Seg_Node(rt->l, m);
        Insert(rt->ch[0], num);
    }
    else
    {
        if (!rt->ch[1])
            rt->ch[1] = new Seg_Node(m + 1, rt->r);
        Insert(rt->ch[1], num);
    }
    rt->Pushup();
}
void Insert(int x, int num)
{
    for (int i = x; i <= n; i += lowbit(i))
    {
        if (root[i] == NULL)
            root[i] = new Seg_Node(0, N);
        Insert(root[i], num);
    }
}
void Delete(Seg_Node *&rt, int num)
{
    if (rt->l == rt->r)
    {
        rt->sum--;
        if (!rt->sum)
            delete rt, rt = NULL;
        return;
    }
    int m = rt->l + rt->r >> 1;
    if (num <= m)
        Delete(rt->ch[0], num);
    else
        Delete(rt->ch[1], num);
    rt->Pushup();
    if (!rt->sum)
        delete rt, rt = NULL;
}
void Delete(int x, int num)
{
    for (int i = x; i <= n; i += lowbit(i))
    {
        Delete(root[i], num);
    }
}
vector<Seg_Node *> Get(int x)
{
    vector<Seg_Node *> ans;
    for (int i = x; i > 0; i -= lowbit(i))
    {
        ans.push_back(root[i]);
    }
    return ans;
}
vector<Seg_Node *> Get_ch(vector<Seg_Node *> x, int op)
{
    for (int i=0;i<x.size();i++)
        if (x[i])
            x[i] = x[i]->ch[op];
    return x;
}
int Query(vector<Seg_Node *> list1, vector<Seg_Node *> list2, int l, int r, int k)
{
    if (l == r)
        return l;
    int ans = 0;
    for (int i=0;i<list2.size();i++)
        if (list2[i])
            ans += sum(list2[i]->ch[0]);
    for (int i=0;i<list1.size();i++)
        if (list1[i])
            ans -= sum(list1[i]->ch[0]);
    int m = l + r >> 1;
    if (ans >= k)
        return Query(Get_ch(list1, 0), Get_ch(list2, 0), l, m, k);
    else
        return Query(Get_ch(list1, 1), Get_ch(list2, 1), m + 1, r, k - ans);
}
void DFS(Seg_Node *&rt)
{
    if (rt)
    {
        DFS(rt->ch[0]);
        DFS(rt->ch[1]);
        delete rt;
        rt=NULL;
    }
}
void remove()
{
    for (int i = 1; i <= n; i++)
    {
        DFS(root[i]);
    }
}
int main(int argc, char const *argv[])
{
    //freopen("dynrank.in","r",stdin);
    //freopen("dynrank.out","w",stdout);
    //int T;
    //scanf("%d", &T);
    //while (T--)
    //{
        int m;
        scanf("%d%d", &n, &m);
        //memset(a,0,sizeof(a));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
            Insert(i, a[i]);
        }
        //sort(a + 1, a + n + 1);
        char op[3];
        int p, b, c;
        for (int i = 1; i <= m; i++)
        {
            scanf("%s", op);
            if (op[0] == 'Q')
            {
                scanf("%d%d%d", &p, &b, &c);
                printf("%d\n", Query(Get(p - 1), Get(b), 0, N, c));
            }
            else
            {
                scanf("%d%d", &p, &b);
                Delete(p, a[p]);
                Insert(p, b);
                a[p] = b;
            }
        }
        remove();
 //   }
    return 0;
}

树套树

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int a[50005], n;
class Treap
{
    class Node
    {
      public:
        int size, v, key;
        Node *ch[2];
        Node(int x)
        {
            key = rand();
            v = x;
            size = 1;
            ch[0] = ch[1] = NULL;
        }
#define size(_) ((_) ? (_)->size : 0)
        void Pushup()
        {
            size = size(ch[0]) + size(ch[1]) + 1;
        }
    } * root;
    Node *Merge(Node *A, Node *B)
    {
        if (!A)
            return B;
        if (!B)
            return A;
        if (A->key > B->key)
        {
            A->ch[1] = Merge(A->ch[1], B);
            A->Pushup();
            return A;
        }
        else
        {
            B->ch[0] = Merge(A, B->ch[0]);
            B->Pushup();
            return B;
        }
    }
    typedef pair<Node *, Node *> DNode;
    DNode Split(Node *rt, int k)
    {
        if (!rt)
            return DNode(NULL, NULL);
        DNode o;
        if (size(rt->ch[0]) >= k)
        {
            o = Split(rt->ch[0], k);
            rt->ch[0] = o.second;
            rt->Pushup();
            o.second = rt;
        }
        else
        {
            o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
            rt->ch[1] = o.first;
            rt->Pushup();
            o.first = rt;
        }
        return o;
    }
  public:
    Treap()
    {
        root = NULL;
    }
    int kth(int k)
    {
        DNode x = Split(root, k - 1);
        DNode y = Split(x.second, 1);
        Node *ans = y.first;
        root = Merge(x.first, Merge(y.first, y.second));
        return ans->v;
    }
    int rank(int x)
    {
        return rank(root, x);
    }
    int rank(Node *rt, int x)
    {
        if (!rt)
            return 0;
        return x <= rt->v ? rank(rt->ch[0], x) : rank(rt->ch[1], x) + size(rt->ch[0]) + 1;
    }
    void Insert(int x)
    {
        int k = rank(root, x);
        DNode y = Split(root, k);
        Node *n = new Node(x);
        root = Merge(Merge(y.first, n), y.second);
    }
    void remove(int x)
    {
        int k = rank(root, x);
        DNode a = Split(root, k);
        DNode b = Split(a.second, 1);
        root = Merge(a.first, b.second);
    }
} root[50005 << 2];
#define lch l, m, rt << 1
#define rch m + 1, r, rt << 1 | 1
void build(int l, int r, int rt)
{
    for (int i = l; i <= r; i++)
        root[rt].Insert(a[i]);
}
void buildtree(int l, int r, int rt)
{
    build(l, r, rt);
    if (l == r)
        return;
    int m = l + r >> 1;
    buildtree(lch);
    buildtree(rch);
}
void updata(int k, int x, int y, int l, int r, int rt)
{
    root[rt].remove(y);
    root[rt].Insert(x);
    if (l == r)
        return;
    int m = l + r >> 1;
    if (k <= m)
        updata(k, x, y, lch);
    else
        updata(k, x, y, rch);
}
int rank(int L, int R, int x, int l, int r, int rt)
{
    if (L <= l && R >= r)
        return root[rt].rank(x);
    int m = l + r >> 1;
    if (R <= m)
        return rank(L, R, x, lch);
    if (L > m)
        return rank(L, R, x, rch);
    return rank(L, R, x, lch) + rank(L, R, x, rch);
}
int kth(int L, int R, int k)
{
    int l = -1e10, r = 1e10;
    while (l <= r)
    {
        int m = l + r >> 1;
        int num = rank(L, R, m, 1, n, 1) + 1;
        if (num <= k)
            l = m + 1;
        else
            r = m - 1;
    }
    return r;
}
int main()
{
    //freopen("dynrank.in", "r", stdin);
    //freopen("dynrank.out", "w", stdout);
    //int T;
    //scanf("%d", &T);
    //while (T--)
    //{
    //    memset(root,0,sizeof(root));
        int m;
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        buildtree(1, n, 1);
        char s[5];
        int i, j, k, t;
        while (m--)
        {
            scanf("%s", s);
            if (s[0] == 'Q')
            {
                scanf("%d%d%d", &i, &j, &k);
                printf("%d\n", kth(i, j, k));
            }
            else
            {
                scanf("%d%d", &i, &t);
                updata(i, t, a[i], 1, n, 1);
                a[i] = t;
            }
        }
    //}
}

COGS 930 [河南省队2012] 找第k小的数

Wed, 02 Aug 2017 21:45:43 GMT

简单题面

求区间第k小

COGS 1534 == 930 找第k小的数本来是主席树或树套树的题然而可持久化Trie树可以过  查了查好像用可持久化Trie做区间k小的人很少啊（我好像是没有查到）事实上可持久化Trie树比较好打，代码很短。本来想用可持久化Treap 做区间k小的结果和 zzh 又调又改弄了一个晚上结果发现是真的不能做啊，Treap 区间不可减他会变化然后想到了可持久化Trie 发现好像可行啊，然后就出来了。跑的好像也很快比树套树和不离散的主席树快。

#include <cstdio>
#include <cstring>
using namespace std;
const int full = 21, fix = 1000001;
struct Trie
{
    struct Trie_Node
    {
        Trie_Node *ch[2];
        int s;
        Trie_Node()
        {
            ch[0] = ch[1] = NULL;
            s = 0;
        }
    } * root[100005],*null;
    Trie()
    {
        null = new Trie_Node();
        null->ch[0] = null->ch[1] = null;
        root[0] = new Trie_Node();
        root[0]->ch[1] = root[0]->ch[0] = null;
    }
    Trie_Node *NewNode()
    {
        Trie_Node *rt = new Trie_Node();
        rt->ch[0] = rt->ch[1] = null;
        return rt;
    }
    void copy(Trie_Node *&a, Trie_Node *b)
    {
        if (b == null)
            a = null;
        else
            a = NewNode(), *a = *b;
    }
    void Insert(int x, int cnt)
    {
        x += fix;
        copy(root[cnt], root[cnt - 1]);
        Trie_Node *rt1 = root[cnt], *rt2 = root[cnt - 1];
        for (int i = full; i >= 0; i--)
        {
            int k = (x >> i) & 1;
            copy(rt1->ch[k], rt2->ch[k]);
            if (rt1->ch[k] == null)
                rt1->ch[k] = NewNode();
            rt1 = rt1->ch[k], rt2 = rt2->ch[k];
            rt1->s++;
        }
    }
    int kth(int k, int l, int r)
    {
        int res = 0;
        Trie_Node *rt1 = root[r], *rt2 = root[l - 1];
        for (int i = full; i >= 0; i--)
        {
            if (k > rt1->ch[0]->s - rt2->ch[0]->s)
            {
                k -= (rt1->ch[0]->s - rt2->ch[0]->s);
                res |= (1 << i);
                rt1 = rt1->ch[1], rt2 = rt2->ch[1];
            }
            else
            {
                rt1 = rt1->ch[0], rt2 = rt2->ch[0];
            }
        }
        return res - fix;
    }
} root;
int main()
{
    freopen("kth.in","r",stdin);
    freopen("kth.out","w",stdout);
    int n, m, a;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a);
        root.Insert(a, i);
    }
    int b, k;
    while (m--)
    {
        scanf("%d%d%d", &a, &b, &k);
        printf("%d\n", root.kth(k, a, b));
    }
}

HDU 5996 dingyeye loves stone

Sun, 30 Jul 2017 20:55:15 GMT

Problem Description

dingyeye loves play stone game with you.

dingyeye has an n-point tree.The nodes are numbered from 0 to n−1,while the root is numbered 0.Initially,there are a[i] stones on the i-th node.The game is in turns.When one move,he can choose a node and move some(this number cannot be 0) of the stones on it to its father.One loses the game if he can't do anything when he moves.  You always move first.You want to know whether you can win the game if you play optimally.

Input

In the first line, there is an integer $ T $ indicating the number of test cases.

In each test case,the first line contains one integer n refers to the number of nodes. The next line contains $ n−1 $ integers $ fa[1]⋯fa[n−1] $,which describe the father of nodes $ 1⋯n−1 $(node 0 is the root).It is guaranteed that $ 0≤fa[i]<i $. The next line contains n integers $ a[0]⋯a[n−1] $,which describe the initial stones on each nodes.It is guaranteed that 0≤a[i]<134217728. $ 1≤T≤100,1≤n≤100000 $.

It is guaranteed that there is at most $ 7 $ test cases such that $n>100$.

Output

For each test case output one line.If you can win the game,print "win".Ohterwise,print "lose".

Sample Input

2
2
0
1000 1
4
0 1 0
2 3 3 3

Sample Output

win
lose

题目大意

由叶节点向根移石子
移不了的输

题解

可看做多个阶梯博弈
将奇数层异或就可以了

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int f[100005], a[100005];
vector<int> ch[100005];
int S;
void DFS(int x,int D)
{
    if(D&1) S^=a[x];
    for(auto i:ch[x])
    {
        DFS(i,D+1);
    }
}
int main(int argc, char const *argv[])
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        int n;
        scanf("%d", &n);
        for (int i = 0; i < n; i++)
            ch[i].clear();
        for (int i = 1; i <= n - 1; i++)
        {
            scanf("%d", &f[i]);
            ch[f[i]].push_back(i);
        }
        for (int i = 0; i <= n - 1; i++)
        {
            scanf("%d", &a[i]);
        }
        S = 0;
        DFS(0,0);
        if(S)
            printf("win\n");
        else 
            printf("lose\n");
    }
    //while(1);
    return 0;
}

POJ 1704 Georgia and Bob

Sun, 30 Jul 2017 20:30:56 GMT

Description

Georgia and Bob decide to play a self-invented game. They draw a row of grids on paper, number the grids from left to right by 1, 2, 3, ..., and place N chessmen on different grids, as shown in the following figure for example:

Georgia and Bob move the chessmen in turn. Every time a player will choose a chessman, and move it to the left without going over any other chessmen or across the left edge. The player can freely choose number of steps the chessman moves, with the constraint that the chessman must be moved at least ONE step and one grid can at most contains ONE single chessman. The player who cannot make a move loses the game.

Georgia always plays first since "Lady first". Suppose that Georgia and Bob both do their best in the game, i.e., if one of them knows a way to win the game, he or she will be able to carry it out.

Given the initial positions of the n chessmen, can you predict who will finally win the game?

Input

The first line of the input contains a single integer T (1 <= T <= 20), the number of test cases. Then T cases follow. Each test case contains two lines. The first line consists of one integer N (1 <= N <= 1000), indicating the number of chessmen. The second line contains N different integers P1, P2 ... Pn (1 <= Pi <= 10000), which are the initial positions of the n chessmen.

Output

For each test case, prints a single line, "Georgia will win", if Georgia will win the game; "Bob will win", if Bob will win the game; otherwise 'Not sure'.

Sample Input

2
3
1 2 3
8
1 5 6 7 9 12 14 17

Sample Output

Bob will win
Georgia will win

简单题意

在 1 * n 的格子上有一些石子
轮流将石子向右移动
不能移动的输

题解

将间隙看做石子
做阶梯博弈
及将奇数层的石子看做 Nim 游戏
偶数层不用管

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int x[100005], b[100005];
int main(int argc, char const *argv[])
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &x[i]);
        }
        sort(x+1,x+n+1);
        for (int i = 1; i <= n; i++)
        {
            b[i] = x[i] - x[i - 1] - 1;
        }
        int S = 0;
        for (int i = n; i >= 1; i -= 2)
        {
            S ^= b[i];
        }
        if (S)
            printf("Georgia will win\n");
        else
            printf("Bob will win\n");
    }
    return 0;
}

[bzoj 1449] [JSOI2009] 球队收益

Sun, 30 Jul 2017 15:45:56 GMT

Description

Input

Output

一个整数表示联盟里所有球队收益之和的最小值。

Sample Input

3 3
1 0 2 1
1 1 10 1
0 1 3 3
1 2
2 3
3 1

Sample Output

43

HINT

题解懒得写了

/*
 * @Author: WildRage 
 * @Date: 2017-07-29 15:51:58 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-07-29 16:05:11
 */
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
int win[5005], lose[5005];
int C[5005], D[5005], du[5005];
const int INF = 0x3f3f3f3f;
class Mincost
{
  public:
    int first[20005], p;
    Mincost()
    {
        memset(first, -1, sizeof(first));
    }
    class edge
    {
      public:
        int END, S, next, cap, cost;
    } v[100005];

    void add(int a, int b, int f, int c)
    {
        v[p].END = b, v[p].next = first[a], v[p].S = a, v[p].cap = f, v[p].cost = c, first[a] = p++;
        v[p].END = a, v[p].next = first[b], v[p].S = b, v[p].cap = 0, v[p].cost = -c, first[b] = p++;
    }
    int dis[20005], pre[20005];
    bool vis[20005];
    bool spfa(int S, int E)
    {
        memset(dis, 0x3f, sizeof(dis));
        memset(pre, -1, sizeof(pre));
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(S);
        vis[S] = 1;
        dis[S] = 0;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            vis[u] = 0;
            for (int i = first[u]; i != -1; i = v[i].next)
            {
                if (!v[i].cap)
                    continue;
                if (dis[v[i].END] > dis[u] + v[i].cost)
                {
                    dis[v[i].END] = dis[u] + v[i].cost;
                    pre[v[i].END] = i;
                    if (!vis[v[i].END])
                    {
                        vis[v[i].END] = 1;
                        Q.push(v[i].END);
                    }
                }
            }
        }
        return dis[E] != 0x3f3f3f3f;
    }
    int MinCost(int S, int T)
    {
        int ans = 0, flow;
        while (spfa(S, T))
        {
            flow = INF;
            for (int i = pre[T]; i != -1; i = pre[v[i].S])
                flow = min(flow, v[i].cap);
            for (int i = pre[T]; i != -1; i = pre[v[i].S])
                v[i].cap -= flow, v[i ^ 1].cap += flow;
            ans += dis[T] * flow;
        }
        return ans;
    }
} Min;
int main(int argc, char const *argv[])
{
    int n, m, a, b;
    int S = 0, T = 10005;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d%d%d", &win[i], &lose[i], &C[i], &D[i]);
    }
    int ans = 0;
    for (int i = 1; i <= m; i++)
    {
        Min.add(S, i, 1, 0);
        scanf("%d%d", &a, &b);
        Min.add(i, m + a, 1, 0);
        Min.add(i, m + b, 1, 0);
        du[a]++, du[b]++;
    }
    for (int i = 1; i <= n; i++)
        lose[i] += du[i];
    for (int i = 1; i <= n; i++)
        ans += lose[i] * lose[i] * D[i] + win[i] * win[i] * C[i];
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= du[i]; j++)
        {
            Min.add(m + i, T, 1, 2 * win[i] * C[i] + C[i] + D[i] - 2 * lose[i] * D[i]);
            lose[i]--;
            win[i]++;
        }
    }
    printf("%d\n", ans + Min.MinCost(S, T));
    //while (1)
        ;
    return 0;
}

[网络流24题] 搭配飞行员

Sun, 30 Jul 2017 15:31:12 GMT

【问题描述】

飞行大队有若干个来自各地的驾驶员，专门驾驶一种型号的飞机，这种飞机每架有两个驾驶员,需一个正驾驶员和一个副驾驶员。由于种种原因，例如相互配合的问题，有些驾驶员不能在同一架飞机上飞行，问如何搭配驾驶员才能使出航的飞机最多。  如图，假设有10个驾驶员，如图中的V1，V2，…，V10就代表达10个驾驶员,其中V1，V2，V3，V4，V5是正驾驶员,V6，V7，V8，V9，V10是副驾驶员。如果一个正驾驶员和一个副驾驶员可以同机飞行，就在代表他们两个之间连一条线,两个人不能同机飞行，就不连。例如V1和V7可以同机飞行，而V1和V8就不行。请搭配飞行员，使出航的飞机最多。注意:因为驾驶工作分工严格,两个正驾驶员或两个副驾驶员都不能同机飞行.

【输入格式】

输入文件有若干行第一行，两个整数n与n1，表示共有n个飞行员(2<=n<=100),其中有n1名飞行员是正驾驶员. 下面有若干行,每行有2个数字a,b。表示正驾驶员a和副驾驶员b可以同机飞行。注:正驾驶员的编号在前,即正驾驶员的编号小于副驾驶员的编号.

【输出格式】

输出文件有一行第一行，1个整数，表示最大起飞的飞机数。

【输入输出样例】

输入文件名： flyer.in

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

输出文件名：flyer.out

题解

二分图直接建图

#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
class Dinic
{
  public:
    struct edge
    {
        int END, next, cap;
    } v[1005];
    int first[105], p;
    Dinic()
    {
        memset(first, -1, sizeof(first));
    }
    void add(int a, int b, int c)
    {
        v[p].END = b, v[p].next = first[a], v[p].cap = c, first[a] = p++;
        v[p].END = a, v[p].next = first[b], v[p].cap = 0, first[b] = p++;
    }
    int dis[105];
    bool vis[10005];
    bool BFS(int S, int E)
    {
        memset(vis, 0, sizeof(vis));
        memset(dis, -1, sizeof(dis));
        queue<int> Q;
        Q.push(S);
        dis[S] = 0;
        vis[S] = 1;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for (int i = first[u]; i != -1; i = v[i].next)
            {
                if (!vis[v[i].END] && v[i].cap > 0)
                {
                    vis[v[i].END] = 1;
                    dis[v[i].END] = dis[u] + 1;
                    if (v[i].END == E)
                        return 1;
                    Q.push(v[i].END);
                }
            }
        }
        return 0;
    }
    int DFS(int S, int E, int a)
    {
        if (S == E || a == 0)
            return a;
        int flow = 0, f;
        for (int i = first[S]; i != -1; i = v[i].next)
        {
            if (dis[v[i].END] == dis[S] + 1 && (f = DFS(v[i].END, E, min(a, v[i].cap)) > 0))
            {
                v[i].cap -= f;
                v[i ^ 1].cap += f;
                a -= f;
                flow += f;
                if (f == 0)
                    break;
            }
        }
        if (!flow)
            dis[S] = -1;
        return flow;
    }
    int dinic(int S, int E)
    {
        int ans = 0;
        while (BFS(S, E))
        {
            ans += DFS(S, E, INF);
        }
        return ans;
    }
} dinic;
 
int main(int argc, char const *argv[])
{
    freopen("flyer.in","r",stdin);
    freopen("flyer.out","w",stdout);
    int n, n1, a, b;
    scanf("%d%d", &n, &n1);
    while (scanf("%d%d", &a, &b) != EOF)
        dinic.add(a, b, 1);
    int S = 0, T = n + 1;
    for (int i = 1; i <= n1; i++)
    {
        dinic.add(S, i, 1);
    }
    for (int i = n1 + 1; i <= n; i++)
    {
        dinic.add(i, T, 1);
    }
    printf("%d\n", dinic.dinic(S, T));
    return 0;
}

vijos 天神下凡

Sun, 30 Jul 2017 15:16:05 GMT

题目描述

Czy找到宝藏获得屠龙宝刀和神秘秘籍！现在他要去找经常ntr他的Jmars报仇……

Czy学会了一招“堕天一击”，他对一个地点发动堕天一击，地面上就会留下一个很大的圆坑。圆坑的周围一圈能量太过庞大，因此无法通过。所以每次czy发动技能都会把地面分割。Jmars拥有好大好大的土地，几十眼都望不到头，所以可以假设土地的大小是无限大。现在czy对他发动了猛烈的攻击，他想知道在泽宇攻击之后他的土地被切成几份了?  Czy毕竟很虚，因此圆心都在x坐标轴上。另外，保证所有圆两两之间不会相交。

输入

输入第一行为整数n，表示czy放了n次堕天一击。

接下来n行，每行两个整数x[i]，r[i]。表示在坐标（x[i] , 0）放了一次堕天一击，半径为r[i]。

输出

输出一行，表示地面被分割成几块。

样例输入

4
7 5
-9 11
11 9
0 20

样例输出

6

题解

那个栈扫一遍

#include <cstdio>
#include <cstring>
#include <stack>
#include <algorithm>
using namespace std;
struct data
{
    int l, r, id;
    bool operator<(const data &a) const
    {
        return l == a.l ? r > a.r : l < a.l;
    }
} a[1000001];
int main(int argc, char const *argv[])
{
    stack<data> st;
    int n, s, r;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d%d", &s, &r);
        a[i].l = s - r, a[i].id = i, a[i].r = s + r;
    }
    sort(a, a + n);
    // for (int i = 0; i < n; i++)
    // {
    //     printf("%d %d %d\n", a[i].l, a[i].r, a[i].id);
    // }
    //while (1)
        ;
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i].l == a[i + 1].l && i + 1 != n - 1)
        {
            st.push(a[i]);
            continue;
        }
        if (!st.empty() && a[i].r == st.top().r)
        {
            st.pop();
            ans++;
        }
        if (a[i].r != a[i + 1].l)
        {
            if (!st.empty())
                st.pop();
        }
    }
    printf("%d", ans + n + 1);
    return 0;
}

[网络流24题] 餐巾

Sun, 30 Jul 2017 15:16:05 GMT

【问题描述】

一个餐厅在相继的N天里，第i天需要Ri块餐巾(i=l，2，…，N)。餐厅可以从三种途径获得餐巾。

购买新的餐巾，每块需p分；
把用过的餐巾送到快洗部，洗一块需m天，费用需f分(f<p)。如m=l时，第一天送到快洗部的餐巾第二天就可以使用了，送慢洗的情况也如此。
把餐巾送到慢洗部，洗一块需n天(n>m)，费用需s分(s<f)。在每天结束时，餐厅必须决定多少块用过的餐巾送到快洗部，多少块送慢洗部。在每天开始时，餐厅必须决定是否购买新餐巾及多少，使洗好的和新购的餐巾之和满足当天的需求量Ri，并使N天总的费用最小。

【输入】

输入文件共 3 行，第 1 行为总天数；第 2 行为每天所需的餐巾块数；第 3 行为每块餐巾的新购费用 p ，快洗所需天数 m ，快洗所需费用 f ，慢洗所需天数 n ，慢洗所需费用 s 。

【输出】

一行，最小的费用

【样例】

napkin.in

3
3 2 4
10 1 6 2 3

napkin.out

64

【数据规模】

n<=200,Ri<=50

题解

将天拆点
由源点向天的第一个点连边
然后由天的第二个点向汇点连边
流量都为Ri 费用为零
由源点向天的第二个点连流量为正无穷费用为p的边
然后由前一天的剩下的向后一天连边
由前一天洗过的向能用的那一天连边
然后跑最小费用最大流就好了

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
class Mincost
{
  public:
    int first[20005], p;
    Mincost()
    {
        memset(first, -1, sizeof(first));
    }
    class edge
    {
      public:
        int END, S, next, cap, cost;
    } v[100005];
 
    void add(int a, int b, int f, int c)
    {
        v[p].END = b, v[p].next = first[a], v[p].S = a, v[p].cap = f, v[p].cost = c, first[a] = p++;
        v[p].END = a, v[p].next = first[b], v[p].S = b, v[p].cap = 0, v[p].cost = -c, first[b] = p++;
    }
    int dis[20005], pre[20005];
    bool vis[20005];
    bool spfa(int S, int E)
    {
        memset(dis, 0x3f, sizeof(dis));
        memset(pre, -1, sizeof(pre));
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(S);
        vis[S] = 1;
        dis[S] = 0;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            vis[u] = 0;
            for (int i = first[u]; i != -1; i = v[i].next)
            {
                if (!v[i].cap)
                    continue;
                if (dis[v[i].END] > dis[u] + v[i].cost)
                {
                    dis[v[i].END] = dis[u] + v[i].cost;
                    pre[v[i].END] = i;
                    if (!vis[v[i].END])
                    {
                        vis[v[i].END] = 1;
                        Q.push(v[i].END);
                    }
                }
            }
        }
        return dis[E] != 0x3f3f3f3f;
    }
    int MinCost(int S, int T)
    {
        int ans = 0, flow;
        while (spfa(S, T))
        {
            flow = INF;
            for (int i = pre[T]; i != -1; i = pre[v[i].S])
                flow = min(flow, v[i].cap);
            for (int i = pre[T]; i != -1; i = pre[v[i].S])
                v[i].cap -= flow, v[i ^ 1].cap += flow;
            ans += dis[T] * flow;
        }
        return ans;
    }
} Min;
int a[205];
int main(int argc, char const *argv[])
{
    freopen("napkin.in","r",stdin);
    freopen("napkin.out","w",stdout);
    int n, p, m, f, c, s;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", a + i);
    }
    scanf("%d%d%d%d%d", &p, &m, &f, &c, &s);
    int S = 0, T = n * 3;
    for (int i = 1; i <= n; i++)
    {
        Min.add(S, i, a[i], 0);
        Min.add(n + i, T, a[i], 0);
        Min.add(S, i + n, INF, p);
        //Min.add(i, i + n, a[i], 0);
        if (i + 1 <= n)
            Min.add(i, i + 1, INF, 0);
        if (i + m <= n)
            Min.add(i, i + n + m, INF, f);
        if (i + c <= n)
            Min.add(i, i + n + c, INF, s);
    }
    printf("%d", Min.MinCost(S, T));
    return 0;
}

vijos 藏宝图

Sun, 30 Jul 2017 06:27:22 GMT

题目描述

Czy爬上黑红树，到达了一个奇怪的地方……

Czy发现了一张奇怪的藏宝图。图上有n个点，m条无向边。已经标出了图中两两之间距离dist。但是czy知道，只有当图刚好又是一颗树的时候，这张藏宝图才是真的。如果藏宝图是真的，那么经过点x的边的边权平均数最大的那个x是藏着宝物的地方。请计算这是不是真的藏宝图，如果是真的藏宝之处在哪里。

输入

输入数据第一行一个数T,表示T组数据。

对于每组数据，第一行一个n，表示藏宝图上的点的个数。

接下来n行,每行n个数，表示两两节点之间的距离。

输出

输出一行或两行。第一行”Yes”或”No”，表示这是不是真的藏宝图。

若是真的藏宝图，第二行再输出一个数，表示哪个点是藏宝之处。

样例输入

2
3
0 7 9
7 0 2
9 2 0
3
0 2 7
2 0 9
7 9 0

样例输出

Yes
1
Yes
3

样例解释:第一棵树的形状是1--2--3。1、2之间的边权是7，2、3之间是2。
第二棵树的形状是2--1--3。2、1之间的边权是2，1、3之间是7。

提示

对于30%数据，n<=50,1<=树上的边的长度<=10^9。对于50%数据，n<=600. 对于100%数据，1<=n<=2500,除30%小数据外任意0<=dist[i][j]<=10^9,T<=5

题解

跑最小生成树
然后跑两两之间距离DFS
比较一下两个矩阵就出来了

vijos 黑红树

Sun, 30 Jul 2017 06:16:02 GMT

题目描述

Mz们在czy的生日送他一个黑红树种子……czy种下种子，结果种子很快就长得飞快，它的枝干伸入空中看不见了……

Czy发现黑红树具有一些独特的性质。

这是二叉树，除根节点外每个节点都有红与黑之间的一种颜色。
每个节点的两个儿子节点都被染成恰好一个红色一个黑色。
这棵树你是望不到头的（树的深度可以到无限大）
黑红树上的高度这样定义:h(根节点)=0，h[son]=h[father]+1。

Czy想从树根顺着树往上爬。他有p/q的概率到达红色的儿子节点，有1-p/q的概率到达黑色节点。但是他知道如果自己经过的路径是不平衡的，他会马上摔下来。一条红黑树上的链是不平衡的，当且仅当红色节点与黑色节点的个数之差大于1。现在他想知道他刚好在高度为h的地方摔下来的概率的精确值a/b，gcd(a,b)=0。那可能很大，所以他只要知道a,b对K取模的结果就可以了。另外，czy对输入数据加密：第i个询问Qi真正大小将是给定的Q减上一个询问的第一个值a%K.

输入

第一行四个数p,q,T,k，表示走红色节点概率是p/q，以下T组询问，答案对K取模。接下来T行，每行一个数 Q,表示czy想知道刚好在高度Q掉下来的概率（已加密）

输出

输出T行，每行两个整数，表示要求的概率a/b中a%K和b%K的精确值。如果这个概率就是0或1，直接输出0 0或1 1（中间有空格）。

样例输入

样例输入1

2 3 2 100
1
2

样例输入2

2 3 2 20
4
6

样例输出

样例输出1

0 0
5 9

样例输出2

0 1 0 9

提示

对于30%数据,p,q<=5,T<=1000,K<=127,对于任意解密后的Q，有Q<=30

对于60%数据,p,q<=20,T<=100000,K<=65535,对于任意解密后的Q,有Q<=1000

对于100%数据,p,q<=100,T<=1000000, K<=1000000007,对于任意解密后的Q,有Q<=1000000

对于100%数据,有q>p,即0<= p/q<=1

题解

不写了
主要就是两行两行的考虑

#include <cstdio>
#include <cstring>
int P;
class frac
{
  public:
    long long a, b;
    long long gcd(long long A, long long B)
    {
        return B == 0 ? A : gcd(B, A % B);
    }
    frac Update(frac s)
    {
        if (s.a == 0)
            return s;
        int GCD = s.gcd(s.a, s.b);
        return (frac){s.a / GCD, s.b / GCD};
    }
    frac operator*(const frac A)
    {
        return (frac){a * A.a % P, b * A.b % P};
    }
    frac operator*(const int A)
    {
        return (frac){a * A % P, b % P};
    }
};
frac ans[1000001];
// 0 b, 1 r
// 0 = ,1 b>r ,2,b<r
int main()
{
    //freopen("brtree.in", "r", stdin);
    //freopen("brtree.out", "w", stdout);
    int p, q, T;
    scanf("%d%d%d%d", &p, &q, &T, &P);
    p %= P;
    q %= P;
    frac B = (frac){q - p, q};
    frac R = (frac){p, q};
    frac BR = B * R * 2;
    frac BBRR = (frac){p * p + (q - p) * (q - p), q * q};
    BR = BR.Update(BR);
    BBRR = BBRR.Update(BBRR);
    ans[2] = BBRR;
    for (int i = 4; i <= 1000000; i += 2)
    {
        ans[i] = ans[i - 2] * BR;
    }
    int k = 0, r = 0;
    while (T--)
    {
        scanf("%d", &k);
        k -= r;
        //int Gcd = ans[k].gcd(ans[k].a, ans[k].b);
        r = 0;
        printf("%lld %lld\n", ans[k].a % P, ans[k].b % P);
        r = ans[k].a % P;
    }
}

BZOJ 2510 弱题

Thu, 27 Jul 2017 21:18:32 GMT

Description

有M个球，一开始每个球均有一个初始标号，标号范围为1～N且为整数，标号为i的球有ai个，并保证Σai = M。每次操作等概率取出一个球（即取出每个球的概率均为1/M），若这个球标号为k（k < N），则将它重新标号为k + 1；若这个球标号为N，则将其重标号为1。（取出球后并不将其丢弃）现在你需要求出，经过K次这样的操作后，每个标号的球的期望个数。

Input

第1行包含三个正整数N，M，K，表示了标号与球的个数以及操作次数。第2行包含N个非负整数ai，表示初始标号为i的球有ai个。

Output

应包含N行，第i行为标号为i的球的期望个数，四舍五入保留3位小数。

Sample Input

2 3 2
3 0

Sample Output

1.667
1.333

HINT

【样例说明】

第1次操作后，由于标号为2球个数为0，所以必然是一个标号为1的球变为标号为2的球。所以有2个标号为1的球，有1个标号为2的球。

第2次操作后，有1/3的概率标号为2的球变为标号为1的球（此时标号为1的球有3个），有2/3的概率标号为1的球变为标号为2的球（此时标号为1的球有1个），所以标号为1的球的期望个数为1/33+2/31 = 5/3。同理可求出标号为2的球期望个数为4/3。

【数据规模与约定】

对于10%的数据，N ≤ 5, M ≤ 5, K ≤ 10；
对于20%的数据，N ≤ 20, M ≤ 50, K ≤ 20；
对于30%的数据，N ≤ 100, M ≤ 100, K ≤ 100；
对于40%的数据，M ≤ 1000, K ≤ 1000；
对于100%的数据，N ≤ 1000, M ≤ 100,000,000, K ≤ 2,147,483,647。

题解

一看k的范围
就能看出要矩阵乘优化
易得矩阵为 $$ \begin{bmatrix} 1-\frac{1}{m} & \frac{1}{m} & 0 & \cdots & 0 \ 0 & 1-\frac{1}{m} & \frac{1}{m} &\cdots & 0 \ \vdots & \vdots & \vdots & \ddots & \vdots \ \frac{1}{m} & 0 & 0 & \cdots & 1-\frac{1}{m} \ \end{bmatrix} $$

然后我们发现n=1000过不了
但是我们发现这个矩阵是一个循环矩阵
只用维护第一行就可以了
降低到$ n^2*log_2{k} $ 就可以跑了

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
struct Martix
{
    double a[1005];
    int n;
    Martix(int x)
    {
        n = x;
        memset(a, 0, sizeof(a));
    }
    Martix operator*(const Martix &b)
    {
        Martix ans(n);
        ans.a[1] = 0;
        for (int i = 1; i <= n; i++)
        {
            for (int k = 1; k <= n; k++)
            {
                int t=(i-k+n+1)%n;
                if(!t) t+=n;
                ans.a[i] += a[k] * b.a[t];
            }
        }
        return ans;
    }
    Martix operator^(const int x)
    {
        Martix a = *this, ans(n);
        int k = x;
        ans.a[1] = 1;
        while (k)
        {
            if (k & 1)
                ans = ans * a;
            k >>= 1;
            a = a * a;
        }
        return ans;
    }
};
int a[1005];
double ans[1005];
int main(int argc, char const *argv[])
{
    int n, m, k;
    scanf("%d%d%d",&n,&m,&k);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    Martix K(n);
    K.a[1] = (double)1 - ((double)1 / m);
    K.a[2] = ((double)1 / m);
    K=K^k;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            int t=(i+j-1)%n;
            if(!t) t+=n;
            ans[t] += K.a[i] * a[j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        printf("%.3lf\n", ans[i]);
    }
    //while(1);
    return 0;
}

[NOIP2011] 玛雅游戏

Thu, 27 Jul 2017 21:04:01 GMT

【问题描述】

Mayan puzzle 是最近流行起来的一个游戏。游戏界面是一个7 行5 列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：

每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图6 到图7）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图1 和图2）；
任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图1 到图3）。注意：
- 如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图4，三个颜色为1 的方块和三个颜色为2 的方块会同时被消除，最后剩下一个颜色为2 的方块）。
- 当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图5 所示的情形，5 个方块会同时被消除）。
方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。注意：掉落的过程中将不会有方块的消除。
上面图1 到图3 给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为（0, 0），将位于（3, 3）的方块向左移动之后，游戏界面从图1 变成图2 所示的状态，此时在一竖列上有连续三块颜色为4 的方块，满足消除条件，消除连续3 块颜色为4 的方块后，上方的颜色为3 的方块掉落，形成图3 所示的局面。

【输入】

输入文件mayan.in，共6 行。
第一行为一个正整数n，表示要求游戏通关的步数。
接下来的5 行，描述7*5 的游戏界面。每行若干个整数，每两个整数之间用一个空格隔开，每行以一个0 结束，自下向上表示每竖列方块的颜色编号（颜色不多于10 种，从1 开始顺序编号，相同数字表示相同颜色）。
输入数据保证初始棋盘中没有可以消除的方块。

【输出】

输出文件名为mayan.out。
如果有解决方案，输出n 行，每行包含3 个整数x，y，g，表示一次移动，每两个整数之间用一个空格隔开，其中（x，y）表示要移动的方块的坐标，g 表示移动的方向，1 表示向右移动，-1 表示向左移动。注意：多组解时，按照x 为第一关健字，y 为第二关健字，1优先于-1，给出一组字典序最小的解。游戏界面左下角的坐标为（0，0）。
如果没有解决方案，输出一行，包含一个整数-1。

mayan.in

3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0

mayan.out

2 1 1
3 1 1
3 0 1

【输入输出样例说明】

按箭头方向的顺序分别为图6 到图11 样例输入的游戏局面如上面第一个图片所示，依次移动的三步是：（2，1）处的方格向右移动，（3，1）处的方格向右移动，（3，0）处的方格向右移动，最后可以将棋盘上所有方块消除。

【数据范围】

对于30%的数据，初始棋盘上的方块都在棋盘的最下面一行；
对于100%的数据，0 < n≤5。

题解

大暴搜
读完题先看数据范围
发现这道题的 n 很小
感觉应该可以搜
然后想到了BFS
一个一个的试
现在的问题就是如何消除和下落在消除的时候横着扫一遍竖着扫一遍
两个for打上标记
然后一遍循环搞掉标记的点
在BFS传参数的时候要注意备份用 memcpy();
在搜的时候及时退出exit(0);
否则可能被卡

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <stack>
#include <cstdlib>
using namespace std;
//#define WILDRAGE 1
int a[6][8];
bool over[6][8];
void print(const int c[6][8])
{
    for (int i = 1; i <= 5; i++)
    {
        for (int j = 1; j <= 7; j++)
            printf("%d ", c[i][j]);
        printf("\n");
    }
    printf("\n");
}
bool ok(const int c[6][8])
{
    //return 0;
    for (int i = 1; i <= 5; i++)
    {
        if (c[i][1])
            return 0;
    }
    return 1;
}
bool remove(int c[6][8])
{
    int it1, it2;
    for (int i = 1; i <= 5; i++)
    {
        it1 = it2 = 1;
        while (1)
        {
            while (c[i][it1] != 0 && it1 <= 7)
                it1++;
            it2 = it1;
            while (c[i][it2] == 0 && it2 <= 7)
                it2++;
            if (it2 != 8)
                swap(c[i][it2], c[i][it1]);
            else
                break;
        }
    }
    // memset(over,0,sizeof(over));
    int times = 1;
    for (int i = 1; i <= 5; i++)
        for (int j = 1; j <= 7; j++)
        {
            if (c[i][j] && c[i][j] == c[i][j - 1])
            {
                times++;
                if (times >= 3 && times < 4)
                {
                    over[i][j - 2] = over[i][j - 1] = over[i][j] = 1;
                }
                if (times >= 4)
                    over[i][j] = 1;
            }
            else
                times = 1;
        }
    times = 1;
    for (int j = 1; j <= 7; j++)
        for (int i = 1; i <= 5; i++)
        {
            if (c[i][j] && c[i][j] == c[i - 1][j])
            {
                times++;
                if (times >= 3 && times < 4)
                {
                    over[i - 2][j] = over[i - 1][j] = over[i][j] = 1;
                }
                if (times >= 4)
                    over[i][j] = 1;
            }
            else
                times = 1;
        }
    bool yes = 0;
    for (int i = 1; i <= 5; i++)
        for (int j = 1; j <= 7; j++)
            if (over[i][j])
                yes = 1, over[i][j] = 0, c[i][j] = 0;
    if (!yes)
        return 0;
    //int it1, it2;
    for (int i = 1; i <= 5; i++)
    {
        it1 = it2 = 1;
        while (1)
        {
            while (c[i][it1] != 0 && it1 <= 7)
                it1++;
            it2 = it1;
            while (c[i][it2] == 0 && it2 <= 7)
                it2++;
            if (it2 != 8)
                swap(c[i][it2], c[i][it1]);
            else
                break;
        }
    }
    return 1;
}
struct data
{
    int x, y, t;
};
stack<data> op;
stack<data> ans;
int n;
void dfs(int t, const int c[6][8])
{
    if (t == n)
    {
#ifdef WILDRAGE
        print(c);
#endif
        if (ok(c))
        {
            while (!op.empty())
            {
                ans.push(op.top());
                op.pop();
            }
            while (!ans.empty())
            {
                printf("%d %d %d\n", ans.top().x - 1, ans.top().y - 1, ans.top().t);
                ans.pop();
            }
            exit(0);
        }
        return;
    }
    else
    {
        int s[6][8];
        for (int i = 1; i <= 5; i++)
        {
            for (int j = 1; j <= 7; j++)
            {
                if (c[i][j] && i + 1 <= 5)
                {
                    op.push((data){i, j, 1});
                    memcpy(s, c, sizeof(s));
                    swap(s[i][j], s[i + 1][j]);
#ifdef WILDRAGE
//print(s);
#endif
                    while (remove(s))
                        ;
#ifdef WILDRAGE
                    printf("%d %d %d\n", i, j, 1);
                    print(s);
#endif
                    dfs(t + 1, s);
                    op.pop();
                }
                if (c[i][j] && i - 1 > 0 && !c[i - 1][j])
                {
                    op.push((data){i, j, -1});
                    memcpy(s, c, sizeof(s));
                    swap(s[i][j], s[i - 1][j]);
#ifdef WILDRAGE
//print(s);
#endif
                    while (remove(s))
                        ;
#ifdef WILDRAGE
                    printf("%d %d %d\n", i, j, -1);
                    print(s);
#endif
                    dfs(t + 1, s);
                    op.pop();
                }
            }
        }
    }
}
int main()
{
#ifndef WILDRAGE
    freopen("mayan.in", "r", stdin);
    freopen("mayan.out", "w", stdout);
#endif
    int s;
    scanf("%d", &n);
    for (int i = 1; i <= 5; i++)
    {
        int j = 0;
        while (scanf("%d", &s))
        {
            if (s == 0)
                break;
            a[i][++j] = s;
        }
        //a[i][0] = j;
    }
#ifdef WILDRAGE
    print(a);
#endif
    dfs(0, a);
    printf("-1\n");
}

BZOJ 2090 [Poi2010] Monotonicity 2

Thu, 27 Jul 2017 20:51:03 GMT

Description

给出N个正整数a[1..N]，再给出K个关系符号（>、<或=）s[1..k]。选出一个长度为L的子序列（不要求连续），要求这个子序列的第i项和第i+1项的的大小关系为s[(i-1)mod K+1]。求出L的最大值。

Input

第一行两个正整数，分别表示N和K (N, K <= 500,000)。第二行给出N个正整数，第i个正整数表示a[i]（a[i] <= 10^6）。第三行给出K个空格隔开关系符号（>、<或=），第i个表示s[i]。

Output

一个正整数，表示L的最大值。

Sample Input

7 3
2 4 3 1 3 5 3
< > =

Sample Output

6

HINT

选出的子序列为2 4 3 3 5 3，相邻大小关系分别是< > = < >。

题解

权值树状数组优化DP
不会正确性证明

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;
const int MaxN = 1000000;
int Max1[MaxN + 5], Max2[MaxN + 5], Max3[MaxN + 5];
#define lowbit(_) ((_) & (-_))
void Update1(int a, int b)
{
    for (int i = a; i <= MaxN; i += lowbit(i))
    {
        Max1[i] = max(b, Max1[i]);
    }
}
void Update2(int a, int b)
{
    for (int i = a; i > 0; i -= lowbit(i))
    {
        Max2[i] = max(b, Max2[i]);
    }
}
int MAX1(int x)
{
    int ans = 0;
    for (int i = x; i > 0; i -= lowbit(i))
    {
        ans = max(ans, Max1[i]);
    }
    return ans;
}
int MAX2(int x)
{
    int ans = 0;
    for (int i = x; i <= MaxN; i += lowbit(i))
    {
        ans = max(ans, Max2[i]);
    }
    return ans;
}
int a[500005], op[500005];
int f[500005][4], n, k;
void add(int len, int a)
{
    int W = (len - 1) % k + 1;
    switch (op[W])
    {
    case 1:
        Update1(a, len);
        break;
    case 2:
        Update2(a, len);
        break;
    case 3:
        Max3[a] = max(len, Max3[a]);
        break;
    default:
        printf("ERROR\n");
        exit(0);
        break;
    }
}
int main()
{
    //freopen("mot.in", "r", stdin);
    //freopen("mot.out", "w", stdout);
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    char c;
    for (int i = 1; i <= k; i++)
    {
        c = getchar();
        while (c != '<' && c != '>' && c != '=')
            c = getchar();
        switch (c)
        {
        case '<':
            op[i] = 1;
            break;
        case '>':
            op[i] = 2;
            break;
        case '=':
            op[i] = 3;
        }
    }
    int ans = 0;
    //f[1][1] = f[1][2] = f[1][3] = 1;
    for (int i = 1; i <= n; i++)
    {
        f[i][1] = MAX1(a[i] - 1) + 1;
        f[i][2] = MAX2(a[i] + 1) + 1;
        f[i][3] = Max3[a[i]] + 1;
        for (int j = 1; j <= 3; j++)
        {
            add(f[i][j], a[i]);
            ans = max(ans, f[i][j]);
        }
    }
    //for(int i=1;i<=n;i++)
    //    printf("%d %d %d\n",f[i][1],f[i][2],f[i][3]);
    // while(1);
    printf("%d", ans);
}

BZOJ 2438 [中山市选2011] 杀人游戏

Thu, 27 Jul 2017 15:52:00 GMT

Description

一位冷血的杀手潜入 Na-wiat，并假装成平民。警察希望能在 N 个人里面，查出谁是杀手。警察能够对每一个人进行查证，假如查证的对象是平民，他会告诉警察，他认识的人，谁是杀手，谁是平民。假如查证的对象是杀手，杀手将会把警察干掉。现在警察掌握了每一个人认识谁。每一个人都有可能是杀手，可看作他们是杀手的概率是相同的。问：根据最优的情况，保证警察自身安全并知道谁是杀手的概率最大是多少？

Input

第一行有两个整数 N,M。接下来有 M 行，每行两个整数 x,y，表示 x 认识 y（y 不一定认识 x,例如胡锦涛同志）。

Output

仅包含一行一个实数，保留小数点后面 6 位，表示最大概率。

Sample Input

5 4
1 2
1 3
1 4
1 5

Sample Output

0.800000

HINT

警察只需要查证 1。假如1是杀手，警察就会被杀。假如 1不是杀手，他会告诉警察 2,3,4,5 谁是杀手。而 1 是杀手的概率是 0.2,所以能知道谁是杀手但没被杀的概率是0.8。

对于 100%的数据有 1≤N ≤100000,0≤M ≤300000 数据已加强！

题解

Tarjan缩点讨论一下入度出度就可以了

#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;
struct edge
{
    int END, next;
} v[1000005], E[1000005];
int first[100005], Efirst[100005], p, Ep;
void add(int a, int c)
{
    v[p].END = c;
    v[p].next = first[a];
    first[a] = p++;
}
void add1(int a, int c)
{
    E[Ep].END = c;
    E[Ep].next = Efirst[a];
    Efirst[a] = Ep++;
}
int S[100005];
int low[100005], dfsn[100005], Index;
bool flag[100005];
int T;
int belong[100005];
stack<int> st;
void tarjan(int rt)
{
    low[rt] = dfsn[rt] = ++Index;
    st.push(rt);
    flag[rt] = 1;
    for (int i = first[rt]; i != -1; i = v[i].next)
    {
        if (!dfsn[v[i].END])
        {
            tarjan(v[i].END);
            low[rt] = min(low[rt], low[v[i].END]);
        }
        else if (flag[v[i].END])
            low[rt] = min(low[rt], dfsn[v[i].END]);
    }
    if (dfsn[rt] == low[rt])
    {
        T++;
        int v;
        do
        {
            v = st.top();
            st.pop();
            flag[v] = 0;
            belong[v] = T;
            S[T]++;
        } while (dfsn[v] != low[v]);
    }
}
int isnroot[100005], ithason[100005];
int main()
{
    memset(first, -1, sizeof(first));
    memset(Efirst, -1, sizeof(Efirst));
    //freopen("killer.in", "r", stdin);
    //freopen("killer.out", "w", stdout);
    int n, m;
    int s, e;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &s, &e);
        add(s, e);
    }
    for (int i = 1; i <= n; i++)
        if (!dfsn[i])
            tarjan(i);
    for (int i = 1; i <= n; i++)
    {
        for (int j = first[i]; j != -1; j = v[j].next)
        {
            if (belong[i] != belong[v[j].END])
            {
                add1(belong[i], belong[v[j].END]);
                isnroot[belong[v[j].END]]++;
                ithason[belong[i]]++;
            }
        }
    }
    int ans = 0;
    bool flags = 0;
    for (int i = 1; i <= T; i++)
    {
        if (!isnroot[i])
        {
            ans++;
            if (flags)
                continue;
            //if (!ithason[i])
            //    flags = 1;
            if (S[i] == 1)
            {
                if (!ithason[i])
                    flags = 1;
                else
                {
                    bool e = 0;
                    for (int j = Efirst[i]; j != -1; j = E[j].next)
                    {
                        if (isnroot[E[j].END] == 1)
                            e = 1;
                    }
                    if (!e)
                        flags = 1;
                }
            }
        }
    }
    // if (!ans)
    //     ans = 1;
    if (flags)
        ans -= 1;
    printf("%.6lf", (double)(n - ans) / n);
}

COGS 1752 [BOI2007] 摩基亚Mokia

Wed, 26 Jul 2017 21:34:23 GMT

【题目描述】

摩尔瓦多的移动电话公司摩基亚（Mokia）设计出了一种新的用户定位系统。和其他的定位系统一样，它能够迅速回答任何形如“用户C的位置在哪？”的问题，精确到毫米。但其真正高科技之处在于，它能够回答形如“给定区域内有多少名用户？”的问题。  在定位系统中，世界被认为是一个W×W的正方形区域，由1×1的方格组成。每个方格都有一个坐标(x,y)，1<=x,y<=W。坐标的编号从1开始。对于一个4×4的正方形，就有1<=x<=4,1<=y<=4（如图）: 请帮助Mokia公司编写一个程序来计算在某个矩形区域内有多少名用户。

【输入格式】

有三种命令，意义如下：

命令	参数	意义
0	W	初始化一个全零矩阵。本命令仅开始时出现一次。
1	x y A	向方格(x,y)中添加A个用户。A是正整数。
2	X1 Y1 X2 Y2	查询X1<=x<=X2，Y1<=y<=Y2所规定的矩形中的用户数量
3	无参数	结束程序。本命令仅结束时出现一次。

【输出格式】

对所有命令2，输出一个一行整数，即当前询问矩形内的用户数量。

【输入样例】

0 4
1 2 3 3
2 1 1 3 3
1 2 2 2
2 2 2 3 4
3

【输出样例】

3
5

【提示】

输入	输出	意义
0 4		大小为4×4的全零正方形
1 2 3 3		向(2,3)方格加入3名用户
2 1 1 3 3		查询矩形1<=x<=3,1<=y<=3内的用户数量
	3	查询结果
1 2 2 2		向(2,2)方格加入2名用户
2 2 2 3 4		查询矩形2<=x<=3,2<=y<=4内的用户数量
	5	查询结果
3		终止程序

【数据规模】

1<=W<=2000000
1<=X1<=X2<=W
1<=Y1<=Y2<=W
1<=x,y<=W
0<A<=10000
命令1不超过160000个。
命令2不超过10000个。

#include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 800010
#define MAXL 2000010
struct Query
{
    int x, y, val, pos, id, opt;
    bool operator<(const Query a) const
    {
        if (x == a.x && y == a.y)
            return opt < a.opt;
        return x == a.x ? y < a.y : x < a.x;
    }
} Ask[MAXN], tmp[MAXN];
int n, m, Ans[MAXN];
class BIT
{
  public:
    int _tree[MAXL];
    BIT() { ; }
#define lowbit(_) ((_) & (-_))
    void Update(int i, int val)
    {
        for (; i <= n; i += lowbit(i))
            _tree[i] += val;
        return;
    }
    int Query(int i)
    {
        int _ans = 0;
        for (; i; i -= lowbit(i))
            _ans += _tree[i];
        return _ans;
    }
} bit;
void add()
{
    int x1, x2, y1, y2;
    scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
    ++Ans[0];
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y1 - 1, Ask[m].val = 1, Ask[m].opt = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2, Ask[m].y = y2, Ask[m].val = 1, Ask[m].opt = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x1 - 1, Ask[m].y = y2, Ask[m].val = -1, Ask[m].opt = 1;
    Ask[++m].pos = Ans[0], Ask[m].x = x2, Ask[m].y = y1 - 1, Ask[m].val = -1, Ask[m].opt = 1;
    return;
}
void CDQ(int l, int r)
{
    if (l == r)
        return;
    int mid = l + r >> 1, l1 = l, l2 = mid + 1;
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid && !Ask[i].opt)
            bit.Update(Ask[i].y, Ask[i].val);
        if (Ask[i].id > mid && Ask[i].opt)
            Ans[Ask[i].pos] += Ask[i].val * bit.Query(Ask[i].y);
    }
    for (int i = l; i <= r; i++)
        if (Ask[i].id <= mid && !Ask[i].opt)
            bit.Update(Ask[i].y, -Ask[i].val);
    for (int i = l; i <= r; i++)
    {
        if (Ask[i].id <= mid)
            tmp[l1++] = Ask[i];
        else
            tmp[l2++] = Ask[i];
    }
    for (int i = l; i <= r; i++)
        Ask[i] = tmp[i];
    CDQ(l, mid);
    CDQ(mid + 1, r);
    return;
}
int main()
{
    int c;
    freopen("mokia.in", "r", stdin);
    freopen("mokia.out", "w", stdout);
    scanf("%d%d", &c, &n);
    while (1)
    {
        int op;
        scanf("%d", &op);
        if (op == 1)
        {
            ++m;
            scanf("%d%d%d", &Ask[m].x, &Ask[m].y, &Ask[m].val);
        }
        else if (op == 2)
        {
            add();
        }
        else
            break;
    }
    for (int i = 1; i <= m; i++)
        Ask[i].id = i;
    sort(Ask + 1, Ask + m + 1);
    CDQ(1, m);
    for (int i = 1; i <= Ans[0]; i++)
        printf("%d\n", Ans[i]);
}

COGS 2235 烤鸡翅

Wed, 26 Jul 2017 21:13:59 GMT

【题目描述】

在焦作太行路上，有一家烤鸡翅的生意火爆。因为好吃，所以卖的特别好。排队的人就特别多，经常有很多人买不到鸡翅。鸡翅会在每分钟烤出Xi个，每分钟也只会卖给一个客人，第i个客人需要买Yi个。因为生意火爆，老板可以选择在这分钟不卖给这个客人鸡翅，或者卖给这个顾客他需要的鸡翅，如果现在剩余的鸡翅不够，那就肯定不能卖给这个客人。无论这个客人能否买到鸡翅，他必须离开队伍。现在给定N分钟，且已经知道每分钟烤出的鸡翅个数Xi，也知道每个客人需要鸡翅的Yi个数，现在老板想知道，如何合理安排卖给与拒绝，最多可以满足多少人

【输入格式】

第一行一个正整数N，表示有N分钟的时间卖鸡翅第二行N个用空格隔开的整数 X1，X2……Xn，Xi表示第i分钟会有Xi个鸡翅烤出第三行N个用空格隔开的整数Y1，Y2……Yn，Yi表示第i分钟的顾客需要Yi个鸡翅

【输出格式】

一个整数，表示最多可以满足买到鸡翅的人数。

【样例输入】

6
2 2 1 2 1 0
1 2 2 3 4 4

【样例输出】

3

【数据范围】

50% 数据保证 N<=1000 100% 1<=N<=250000 Xi,Yi都在[0,10^9]范围内

题解

能卖就卖
卖不了了如何以前有人买的数目比他多
那就不卖给以前的那个人了也就是收回来
可后悔的贪心，长见识了。主要使用优先队列

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
int x[250005], y[250005];
class comp
{
  public:
    bool operator()(long long a, long long b)
    {
        return y[a] < y[b];
    }
};
priority_queue<long long, vector<long long>, comp> Q;
int main()
{
    freopen("wing.in", "r", stdin);
    freopen("wing.out", "w", stdout);
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &x[i]);
    for (int i = 1; i <= n; i++)
        scanf("%d", &y[i]);
    long long sum = 0;
    for (int i = 1; i <= n; i++)
    {
        sum += x[i];
        if (sum >= y[i])
            sum -= y[i], Q.push(i);
        else
        {
            if (!Q.empty())
            {
                if (y[Q.top()] > y[i])
                {
                    sum += y[Q.top()];
                    Q.pop();
                    sum -= y[i];
                    Q.push(i);
                }
            }
        }
    }
    printf("%d\n", Q.size());
}

BZOJ 3668 [NOI2014] 起床困难综合症

Wed, 26 Jul 2017 21:03:23 GMT

Description

21 世纪，许多人得了一种奇怪的病：起床困难综合症，其临床表现为：起床难，起床后精神不佳。作为一名青春阳光好少年，atm 一直坚持与起床困难综合症作斗争。通过研究相关文献，他找到了该病的发病原因：在深邃的太平洋海底中，出现了一条名为 drd 的巨龙，它掌握着睡眠之精髓，能随意延长大家的睡眠时间。正是由于 drd 的活动，起床困难综合症愈演愈烈，以惊人的速度在世界上传播。为了彻底消灭这种病，atm 决定前往海底，消灭这条恶龙。历经千辛万苦，atm 终于来到了 drd 所在的地方，准备与其展开艰苦卓绝的战斗。drd 有着十分特殊的技能，他的防御战线能够使用一定的运算来改变他受到的伤害。具体说来，drd 的防御战线由 n扇防御门组成。每扇防御门包括一个运算op和一个参数t，其中运算一定是OR,XOR,AND中的一种，参数则一定为非负整数。如果还未通过防御门时攻击力为x，则其通过这扇防御门后攻击力将变为x op t。最终drd 受到的伤害为对方初始攻击力x依次经过所有n扇防御门后转变得到的攻击力。由于atm水平有限，他的初始攻击力只能为0到m之间的一个整数（即他的初始攻击力只能在0,1,...,m中任选，但在通过防御门之后的攻击力不受 m的限制）。为了节省体力，他希望通过选择合适的初始攻击力使得他的攻击能让 drd 受到最大的伤害，请你帮他计算一下，他的一次攻击最多能使 drd 受到多少伤害。

Input

第1行包含2个整数，依次为n,m，表示drd有n扇防御门，atm的初始攻击力为0到m之间的整数。接下来n行，依次表示每一扇防御门。每行包括一个字符串op和一个非负整数t，两者由一个空格隔开，且op在前，t在后，op表示该防御门所对应的操作， t表示对应的参数。n<=10^5

Output

一行一个整数，表示atm的一次攻击最多使 drd 受到多少伤害。

Sample Input

3 10
AND 5
OR 6
XOR 7

Sample Output

1

HINT

【样例说明1】

atm可以选择的初始攻击力为0,1,...,10。

假设初始攻击力为4，最终攻击力经过了如下计算

4 AND 5 = 4

4 OR 6 = 6

6 XOR 7 = 1

类似的，我们可以计算出初始攻击力为1,3,5,7,9时最终攻击力为0，初始攻击力为0,2,4,6,8,10时最终攻击力为1，因此atm的一次攻击最多使 drd 受到的伤害值为1。

0<=m<=10^9

0<=t<=10^9

一定为OR,XOR,AND 中的一种

【运算解释】

在本题中，选手需要先将数字变换为二进制后再进行计算。如果操作的两个数二进制长度不同，则在前补0至相同长度。OR为按位或运算，处理两个长度相同的二进制数，两个相应的二进制位中只要有一个为1，则该位的结果值为1，否则为0。XOR为按位异或运算，对等长二进制模式或二进制数的每一位执行逻辑异或操作。如果两个相应的二进制位不同（相异），则该位的结果值为1，否则该位为0。 AND 为按位与运算，处理两个长度相同的二进制数，两个相应的二进制位都为1，该位的结果值才为1，否则为0。

例如，我们将十进制数5与十进制数3分别进行OR，XOR 与 AND 运算，可以得到如下结果：

OR	XOR	AND
0101 (十进制 5)	0101 (十进制 5)	0101 (十进制 5)
OR 0011 (十进制 3)	XOR 0011 (十进制 3)	AND 0011 (十进制 3)
= 0111 (十进制 7)	= 0110 (十进制 6)	= 0001 (十进制 1)

题解

贪心的考虑每一位
如果这一位为0能使结果的这一位为1在这一位一定是0
如果为1的话在高位一定比在低位优
所以如果这一位不能为0而1可以的话能为1则为1 否则为0

代码打的很傻

#include <cstdio>
#include <cstring>
using namespace std;
int a[100005], op[100005];
int er[31][100005];
int n, m;
void to_two(int c, int j)
{
    int i = 1;
    while (c)
    {
        er[i][j] = (c & 1);
        i++, c >>= 1;
    }
}
bool judge(int j, int c)
{
    int ans = c;
    for (int i = 1; i <= n; i++)
    {
        if (op[i] == 1)
            ans &= er[j][i];
        else if (op[i] == 2)
            ans |= er[j][i];
        else if (op[i] == 3)
            ans ^= er[j][i];
    }
    return ans;
}
int main()
{
    //freopen("sleep.in","r",stdin);
    //freopen("sleep.out","w",stdout);
    scanf("%d%d", &n, &m);
    char c[10];
    for (int i = 1; i <= n; i++)
    {
        scanf("%s", c);
        if (c[0] == 'A')
            op[i] = 1;
        else if (c[0] == 'O')
            op[i] = 2;
        else
            op[i] = 3;
        scanf("%d", &a[i]);
        to_two(a[i], i);
    }
    int ans = 0;
    //printf("%d\n",ans);
    for (int i = 29; i > 0; i--)
    {
        if (judge(i, 0))
            ;
        else
        {
            if (judge(i, 1))
                if ((ans | (1 << (i - 1))) <= m)
                    ans |= (1 << (i - 1));
        }
        //printf("%d\n",ans);
    }
    //printf("%d\n",ans);
    for (int i = 1; i <= n; i++)
    {
        if (op[i] == 1)
            ans &= a[i];
        else if (op[i] == 2)
            ans |= a[i];
        else if (op[i] == 3)
            ans ^= a[i];
    }
    printf("%d", ans);
}

COGS 2421 简单的Treap

Wed, 26 Jul 2017 20:53:01 GMT

【题目描述】

Treap是一种平衡二叉搜索树，除二叉搜索树的基本性质外，Treap还满足一个性质：每个节点都有一个确定的优先级，且每个节点的优先级都比它的两个儿子小(即它的优先级满足堆性质)。不难证明在节点的优先级都事先给定且互不相同时，对应的Treap有且仅有一个。现在，给定n个数和每个数对应的优先级，求出对应的以数的大小作为二叉搜索树比较依据的Treap的先序遍历结果。对先序遍历的定义是：先访问根节点，再访问左子树，最后访问右子树。

【输入格式】

第一行一个数n表示数的个数。第二行n个数表示每个数的大小。第三行n个数表示每个数对应的优先级。

【输出格式】

一行n个数，表示Treap的先序遍历结果(对于每个节点，输出对应的数)。

【样例输入】

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

【样例输出】

5 2 1 3 4 9 11

【样例解释】

对应的Treap如图所示，其中圈内的数是给出的数，圈外的数是节点的优先级。

【数据范围】

n<=500000。所有的数和优先级都互不相同且在int(C++)/longint(Pascal)范围内。

【提示】

为了给不想用栈模拟递归的孩纸们偷懒的机会，C++选手请在main函数的开头加入以下代码：

int __size__=128<<20;
char *__p__=(char*)malloc(__size__)+__size__;
__asm__("movl %0, %%esp\n"::"r"(__p__));

注意上述代码会占用你128MB的空间，请自行调整代码。

题解

其实就是排序后用笛卡尔树建一颗树

所以这道题是一道笛卡尔树的裸题

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
class data
{
  public:
    int v, key;
    bool operator<(const data &a) const
    {
        return v < a.v;
    }
} a[500005];
class Node
{
  public:
    Node *ch[2];
    int key, v;
    Node(data x)
    {
        key = x.key;
        v = x.v;
        ch[0] = ch[1] = NULL;
    }
    ~Node();
} * st[500005];
Node *build(int m)
{
    Node *x, *last;
    int p = 0;
    for (int i = 1; i <= m; i++)
    {
        x = new Node(a[i]);
        last = NULL;
        while (p && st[p]->key > x->key)
        {
            last = st[p];
            st[p--] = NULL;
        }
        if (p)
            st[p]->ch[1] = x;
        x->ch[0] = last;
        st[++p] = x;
    }
    return st[1];
}
void dfs(Node *a)
{
    if (a)
    {
        printf("%d ", a->v);
        dfs(a->ch[0]);
        dfs(a->ch[1]);
    }
}
int main()
{
    int __size__ = 128 << 20;
    char *__p__ = (char *)malloc(__size__) + __size__;
    __asm__("movl %0, %%esp\n" ::"r"(__p__));
    freopen("treap.in","r",stdin);
    freopen("treap.out","w",stdout);
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i].v);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i].key);
    sort(a + 1, a + n + 1);
    Node *rt = build(n);
    dfs(rt);
}

BZOJ 2818 GCD

Wed, 26 Jul 2017 20:21:12 GMT

Description

给定整数N，求1<=x,y<=N且Gcd(x,y)为素数的数对(x,y)有多少对.

Input

一个整数N

Output

如题

Sample Input

4

Sample Output

4

题解

$$ \sum_{d}{\sum_{i=1}^{n}{\sum_{j=1}^{n}[gcd(i,j)=d]}} $$

$$ = \sum_{d}{\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}{\sum_{j=1}^{\lfloor\frac{n}{d}\rfloor}{[gcd(i,j)=1]}}} $$

$$ = \sum_{T}{\lfloor\frac{n}{T}\rfloor \lfloor\frac{n}{T}\rfloor\sum_{d|T}{\mu(\frac{n}{T})}} $$
令 $f[i]=\sum_{d|T}^{} \mu(\frac{T}{d})$

然后线性筛

#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 10000000;
int mu[N + 5], prime[N + 5], g[N + 5];
long long sum[N + 5], cnt;
bool isnprime[N + 5];
void get_g()
{
    mu[1] = 1;
    for (int i = 2; i <= N; i++)
    {
        if (!isnprime[i])
        {
            prime[++cnt] = i;
            mu[i] = -1;
            g[i] = 1;
        }
        for (int j = 1; j <= cnt && i * prime[j] <= N; j++)
        {
            isnprime[i * prime[j]] = 1;
            if (i % prime[j])
                mu[i * prime[j]] = -mu[i], g[i * prime[j]] = mu[i] - g[i];
            else
            {
                mu[i * prime[j]] = 0;
                g[i * prime[j]] = mu[i];
                break;
            }
        }
    }
    for (int i = 1; i <= N; i++)
    {
        sum[i] = sum[i - 1] + g[i];
    }
}
int main()
{
    get_g();
    int n;
    scanf("%d", &n);
    long long ans = 0, last;
    for (int i = 1; i <= n; i = last + 1)
    {
        last = n / (n / i);
        ans += (long long)(sum[last] - sum[i - 1]) * (n / i) * (n / i);
    }
    printf("%lld\n", ans);
}

BZOJ 1500 [NOI2005] 维护数列

Sat, 15 Jul 2017 15:56:21 GMT

【问题描述】

题目链接 BZOJ COGS

【输入格式】

输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M表示要进行的操作数目。第 2 行包含 N 个数字，描述初始时的数列。以下 M 行，每行一条命令，格式参见问题描述中的表格。

【输出格式】

对于输入数据中的 GET-SUM 和 MAX-SUM 操作，向输出文件依次打印结果，每个答案（数字）占一行。

【输入样例】

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

【输出样例】

-1
10
1
10

【样例说明】

初始时，我们拥有数列 2 -6 3 5 1 -5 -3 6 3 执行操作 GET-SUM 5 4，表示求出数列中从第 5 个数开始连续 4 个数字之和，1+(-5)+(-3)+6 = -1：

2 -6 3 5 1 -5 -3 6 3

执行操作 MAX-SUM，表示要求求出当前数列中最大的一段和，应为 3+5+1+(-5)+(-3)+6+3 = 10：

2 -6 3 5 1 -5 -3 6 3

执行操作 INSERT 8 3 -5 7 2，即在数列中第 8 个数字后插入-5 7 2，

2 -6 3 5 1 -5 -3 6 -5 7 2 3

执行操作 DELETE 12 1，表示删除第 12 个数字，即最后一个：

2 -6 3 5 1 -5 -3 6 -5 7 2

执行操作 MAKE-SAME 3 3 2，表示从第 3 个数开始的 3 个数字，统一修改为 2：

2 -6 3 5 1 -5 -3 6 -5 7 2

改为

2 -6 2 2 2 -5 -3 6 -5 7 2

执行操作 REVERSE 3 6，表示取出数列中从第 3 个数开始的连续 6 个数：

2 -6 2 2 2 -5 -3 6 -5 7 2

如上所示的灰色部分 2 2 2 -5 -3 6，翻转后得到 6 -3 -5 2 2 2，并放回原来位置：

2 -6 6 -3 -5 2 2 2 -5 7 2

最后执行 GET-SUM 5 4 和 MAX-SUM，不难得到答案 1 和 10。

2 -6 6 -3 -5 2 2 2 -5 7 2

BZOJ 版

题解

本题要求维护 动态连续最大连续和 和 区间和
所以要用 Max，和 Sum 来记录
类似线段树我们需要Pushdown和Pushup函数
此外对于Max 为了更新他的值，我们还需要维护两个变量 l，r 分别记录前缀最大和&后缀最大和

向上传递的

对于一个节点更新Max时要分一下几种情况讨论
1. 它的左儿子的Max
2. 它的右儿子的Max
3. 它的左儿子的r加上本节点的权值v
4. 它的右儿子的l加上本节点的权值v
5. 它的左儿子的r加上本节点的权值v加上右儿子的l
用一张图来表示是这样的
我们还需要维护一个节点的 l 与上面相似要分三种情况
1. 它的左儿子的 l
2. 它的左儿子的 sum 加上本节点的权值v
3. 它的左节点的 sum 加上本节点的权值v 加上他的右儿子的 l
用另一张张图来表示是这样的
r与上面的相似
1. 它的右儿子的 r
2. 它的右儿子的 sum 加上本节点的权值v
3. 它的右节点的 sum 加上本节点的权值v 加上他的左儿子的 r
不想画图了╭(╯^╰)╮
然后是Sum 直接加起来就好了

向下传递的

首先是旋转标记
1. 直接下传然后交换左右儿子即可
2. 注意异或的用法
然后是修改标记
1. 首先你不能暴力修改有一个点会超时，亲测
2. 所以想线段树一样我们需要一个标记
3. 下传时注意维护Max，sum，l，r 这些值
  
  对于Sum 直接乘就好
  
  对于Max,l,r 要分类讨论
  1. 如果改变的值为负数那这三个的值都未你改变成的值
  2. 否则这等于Sum
对于插入
直接新建一颗树插进去就可以了

最后一步码代码调程序

能Pushdown() 就Pushdown()
能Pushup() 就Pushup()

fhq Treap 真好
如果打Splay 我会死的

另外需要注意如果子树为空的返回值

链接们

fhq大佬挖掘Treap的潜力 - fanhq666的日志
我的板子来源非旋转Treap及可持久化[Merge,Split] Memphis's Blog
附朋友的题解 [您有新的未分配科技点] 无旋treap：从单点到区间（例题 BZOJ1500&NOI2005 维护数列）
[您有新的未分配科技点]无旋treap：从好奇到入门（例题：bzoj3224 普通平衡树）

C++ Code

/*
 * @Author: WildRage 
 * @Date: 2017-07-15 10:32:15 
 * @Last Modified by:   WildRage 
 * @Last Modified time: 2017-07-15 15:07:46 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
struct Node
{
    int v, key, size, rev;
    int Max, l, r, sum, change;
    Node *ch[2];
    Node(int x)
    {
        v = x;
        key = rand();
        size = 1;
        rev = 0;
        change = -INF;
        Max = x;
        l = x;
        r = x;
        sum = x;
        ch[0] = ch[1] = NULL;
    }
#define size(_) ((_) ? (_)->size : (0))
#define sum(_) ((_) ? (_)->sum : (0))
#define l(_) ((_) ? (_)->l : (-INF))
#define r(_) ((_) ? (_)->r : (-INF))
#define Max(_) ((_) ? (_)->Max : (-INF))
#define change(_) ((_) ? (_)->change : (-INF))
    void Pushup()
    {
        size = 1 + size(ch[1]) + size(ch[0]);
        l = max(l(ch[0]), max(sum(ch[0]) + v, sum(ch[0]) + v + l(ch[1])));
        r = max(r(ch[1]), max(sum(ch[1]) + v, sum(ch[1]) + v + r(ch[0])));
        Max = max(Max(ch[0]), max(Max(ch[1]), max(r(ch[0]) + v, max(l(ch[1]) + v, max(r(ch[0]) + l(ch[1]) + v, v)))));
        sum = sum(ch[0]) + sum(ch[1]) + v;
    }
    void reverse()
    {
        if (!this)
            return;
        swap(ch[0], ch[1]);
        swap(l, r);
        rev ^= 1;
    }
    void Update()
    {
        if (!this)
            return;
        if (ch[1])
            ch[1]->change = change;
        if (ch[0])
            ch[0]->change = change;
        sum = size * change;
        v=change;
        l=r=Max=max(change,size*change);
        //change = -INF;
    }
    void Pushdown()
    {
        if (!this)
            return;
        if (rev)
        {
            ch[0]->reverse();
            ch[1]->reverse();
            rev = 0;
        }
        if (change != -INF)
        {
            ch[0]->Update();
            ch[1]->Update();
            change=-INF;
        }
    }
} * root;
typedef pair<Node *, Node *> DNode;
Node *Merge(Node *A, Node *B)
{
    if (!A)
        return B;
    if (!B)
        return A;
    if (A->key < B->key)
    {
        A->Pushdown();
        A->ch[1] = Merge(A->ch[1], B);
        A->Pushup();
        return A;
    }
    else
    {
        B->Pushdown();
        B->ch[0] = Merge(A, B->ch[0]);
        B->Pushup();
        return B;
    }
}
DNode Split(Node *rt, int k)
{
    if (!rt)
        return DNode(NULL, NULL);
    DNode o;
    rt->Pushdown();
    if (size(rt->ch[0]) >= k)
    {
        o = Split(rt->ch[0], k);
        rt->ch[0] = o.second;
        rt->Pushup();
        o.second = rt;
    }
    else
    {
        o = Split(rt->ch[1], k - size(rt->ch[0]) - 1);
        rt->ch[1] = o.first;
        rt->Pushup();
        o.first = rt;
    }
    return o;
}
Node *st[4000005];
Node *build(int m)
{
    //memset(st, 0, sizeof(st));
    Node *x, *last;
    int p = 0;
    int a;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d", &a);
        x = new Node(a);
        last = NULL;
        while (p && st[p]->key > x->key)
        {
            st[p]->Pushup();
            last = st[p];
            st[p--] = NULL;
        }
        if (p)
            st[p]->ch[1] = x;
        x->ch[0] = last;
        st[++p] = x;
    }
    while (p)
        st[p--]->Pushup();
    return st[1];
}
Node *kth(int k)
{
    DNode x = Split(root, k - 1);
    DNode y = Split(x.second, 1);
    Node *ans = y.first;
    root = Merge(Merge(x.first, ans), y.second);
    return ans;
}
int Rank(Node *rt, int x)
{
    if (!rt)
        return 0;
    return x <= rt->v ? Rank(rt->ch[0], x) : Rank(rt->ch[1], x) + size(rt->ch[0]) + 1;
}
void Insert(int x)
{
    int k = Rank(root, x);
    DNode y = Split(root, k);
    Node *n = new Node(x);
    root = Merge(Merge(y.first, n), y.second);
}
void remove(int x)
{
    int k = Rank(root, x);
    DNode a = Split(root, k);
    DNode b = Split(a.second, 1);
    root = Merge(a.first, b.second);
}
void flip(int i, int m)
{
    DNode x = Split(root, i - 1);
    DNode y = Split(x.second, m);
    y.first->reverse();
    root = Merge(x.first, Merge(y.first, y.second));
}
void dfs(Node *rt)
{
    if (rt)
    {
        rt->Pushdown();
        dfs(rt->ch[0]);
        printf("%d ", rt->v);
        dfs(rt->ch[1]);
    }
}
void Insert(int i, int tot)
{
    Node *x = build(tot);
    DNode y = Split(root, i);
    root = Merge(y.first, Merge(x, y.second));
}
void rmdfs(Node *rt)
{
    if (rt)
    {
        rmdfs(rt->ch[0]);
        rmdfs(rt->ch[1]);
    }
    delete rt;
}
void remove(int i, int tot)
{
    DNode x = Split(root, i - 1);
    DNode y = Split(x.second, tot);
    rmdfs(y.first);
    root = Merge(x.first, y.second);
}
void Update(int i, int tot, int c)
{
    DNode x = Split(root, i - 1);
    DNode y = Split(x.second, tot);
    y.first->change = c;
    y.first->Update();
    //Node *m = build(tot, c);
    //rmdfs(y.first);
    root = Merge(x.first, Merge(y.first, y.second));
}
int get_sum(int i, int tot)
{
    DNode x = Split(root, i - 1);
    DNode y = Split(x.second, tot);
    int ans = sum(y.first);
    root = Merge(x.first, Merge(y.first, y.second));
    return ans;
}
int Max_Sum()
{
    return Max(root);
}
int main()
{
    //freopen("seq2005.in", "r", stdin);
    //freopen("seq2005.out", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    root = build(n);
    //dfs(root);
    //printf("----------------------\n");
    int l, r, c;
    char s[16];
    for (int i = 1; i <= m; i++)
    {
        scanf("%s", s);
        switch (s[0])
        {
        case 'G':
            scanf("%d%d", &l, &r);
            printf("%d\n", get_sum(l, r));
            break;
        case 'D':
            scanf("%d%d", &l, &r);
            remove(l, r);
            break;
        case 'I':
            scanf("%d%d", &l, &r);
            Insert(l, r);
            break;
        case 'R':
            scanf("%d%d", &l, &r);
            flip(l, r);
            break;
        case 'M':
            if (s[2] == 'K')
            {
                scanf("%d%d%d", &l, &r, &c);
                Update(l, r, c);
            }
            else
            {
                printf("%d\n", Max_Sum());
            }
        }
        //printf("--------------------------------\n");
        //dfs(root);
        //printf("\n-----------DONE-----------------\n");
    }
    //while (1)
    ;
}

BZOJ 1875 [SDOI2009]HH去散步矩阵乘

Thu, 13 Jul 2017 18:00:56 GMT

Made by WZZ

Description

HH有个一成不变的习惯，喜欢饭后百步走。所谓百步走，就是散步，就是在一定的时间内，走过一定的距离。但是同时HH又是个喜欢变化的人，所以他不会立刻沿着刚刚走来的路走回。又因为HH是个喜欢变化的人，所以他每天走过的路径都不完全一样，他想知道他究竟有多少种散步的方法。现在给你学校的地图（假设每条路的长度都是一样的都是1），问长度为t，从给定地点A走到给定地点B共有多少条符合条件的路径

Input

第一行：五个整数N，M，t，A，B。
N表示学校里的路口的个数
M表示学校里的路的条数
t表示HH想要散步的距离
A表示散步的出发点
B则表示散步的终点。
接下来M行
每行一组Ai，Bi，表示从路口Ai到路口Bi有一条路。
数据保证Ai ！= Bi,但不保证任意两个路口之间至多只有一条路相连接。
路口编号从0到N -1。
同一行内所有数据均由一个空格隔开，行首行尾没有多余空格。没有多余空行。
答案模45989。
N ≤ 20，M ≤ 60，t ≤ 2^30，0 ≤ A,B

Output

一行，表示答案。

Sample Input

4 5 3 0 0
0 1
0 2
0 3
2 1
3 2

Sample Output

4

这道题是一道矩阵乘的题
通常我们用矩阵乘表示点a 到点b
$$ \begin{matrix} 1 & 2 & 3 & 4 & ..... & N-1 & N \ \end{matrix} $$ 1 2 3 4 .....N-1 N 1-1 1-2 .... N-1
2-1 2-2 .... N-2
3-1 3-2 .... N-3
... ... .... ...
N-1 N-2 .... N-N

乘之后便为到 i点的方案数
但这道题有不能重复走边的限制
我们便巧妙地用矩阵储存边
边 i 能到达边 j的条件为 edge[i].to==edge[j].from(即相连)
但 i不能到达i+1条边（i为偶数）所以a[i][i+1]=0;
再循环找满足条件即可

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define mod 45989
using namespace std;

int n, m, t, size, head[25], began, endd, x, y;
int a[160][160], ans[160][160], tot;
struct node
{
    int from, to, next;
} edge[400];
void add(int from, int to)
{
    edge[++size].from = from;
    edge[size].to = to;
    edge[size].next = head[from];
    head[from] = size;
}

void cheng(int a[160][160], int b[160][160], int to[160][160])
{
    int tmp[160][160] = {0};
    for (int i = 1; i <= size; i++)
        for (int j = 1; j <= size; j++)
            for (int u = 1; u <= size; u++)
                tmp[i][j] = (tmp[i][j] + a[i][u] * b[u][j] % mod) % mod;
    for (int i = 1; i <= size; i++)
        for (int j = 1; j <= size; j++)
            to[i][j] = tmp[i][j];
}

void dp()
{
    while (t)
    {
        if (t & 1)
            cheng(a, ans, ans);
        t = t >> 1;
        cheng(a, a, a);
    }
    for (int i = 1; i <= size; i++)
        if (edge[i].to == endd)
            for (int j = 1; j <= size; j++)
                if (edge[j].from == began)
                    tot = (tot + ans[j][i]) % mod;
}

int main()
{
    scanf("%d%d%d%d%d", &n, &m, &t, &began, &endd);
    began++, endd++;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &x, &y);
        x++, y++;
        add(x, y);
        add(y, x);
    }
    for (int i = 1; i <= size; i++)
        for (int j = 1; j <= size; j++)
            if (edge[i].to == edge[j].from)
                a[i][j] = 1;

    for (int i = 1; i <= size; i += 2)
        a[i][i + 1] = a[i + 1][i] = 0;

    for (int i = 1; i <= size; i++)
        ans[i][i] = 1;
    t--;
    dp();
    printf("%d", tot);
}

BZOJ 3038 上帝造题的七分钟2 线段树

Thu, 13 Jul 2017 17:31:56 GMT

Description

XLk觉得《上帝造题的七分钟》不太过瘾，于是有了第二部。 "第一分钟，X说，要有数列，于是便给定了一个正整数数列。第二分钟，L说，要能修改，于是便有了对一段数中每个数都开平方(下取整)的操作。第三分钟，k说，要能查询，于是便有了求一段数的和的操作。第四分钟，彩虹喵说，要是noip难度，于是便有了数据范围。第五分钟，诗人说，要有韵律，于是便有了时间限制和内存限制。第六分钟，和雪说，要省点事，于是便有了保证运算过程中及最终结果均不超过64位有符号整数类型的表示范围的限制。第七分钟，这道题终于造完了，然而，造题的神牛们再也不想写这道题的程序了。" ——《上帝造题的七分钟·第二部》所以这个神圣的任务就交给你了。

Input

第一行一个整数n，代表数列中数的个数。第二行n个正整数，表示初始状态下数列中的数。第三行一个整数m，表示有m次操作。接下来m行每行三个整数k,l,r，k=0表示给[l,r]中的每个数开平方(下取整)，k=1表示询问[l,r]中各个数的和。

Output

对于询问操作，每行输出一个回答。

Sample Input

10
1 2 3 4 5 6 7 8 9 10
5
0 1 10
1 1 10
1 1 5
0 5 8
1 4 8

Sample Output

19
7
6

HINT

1：对于100%的数据，1<=n<=100000，1<=l<=r<=n，数列中的数大于0，且不超过1e12。 2：数据不保证L<=R 若L>R，请自行交换L,R，谢谢！

题解

线段树去修改就可以了
区间为1后就不用改了
很暴力的

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define LL long long
#define lch l, m, rt << 1
#define rch m + 1, r, rt << 1 | 1

const int N = 100005;
LL Min[N << 2], Max[N << 2], Sum[N << 2];
int Sqr[N << 2];
void Pushup(int rt)
{
    Min[rt] = min(Min[rt << 1], Min[rt << 1 | 1]);
    Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
    if (Sum[rt << 1] != -1 && Sum[rt << 1 | 1] != -1)
        Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1];
    else
        Sum[rt] = -1;
}
void Pushdown(int rt, int s)
{
    if (Sqr[rt])
    {
        Sqr[rt << 1] += Sqr[rt];
        Sqr[rt << 1 | 1] += Sqr[rt];
        Sum[rt << 1] = Sum[rt << 1 | 1] = -1;
        if (Max[rt << 1] > 1)
            for (int i = 1; i <= Sqr[rt]; i++)
            {
                Max[rt << 1] = sqrt(Max[rt << 1]);
                Min[rt << 1] = sqrt(Min[rt << 1]);
                if (Max[rt << 1] == 1)
                    break;
            }
        if (Max[rt << 1 | 1] > 1)
            for (int i = 1; i <= Sqr[rt]; i++)
            {
                Max[rt << 1 | 1] = sqrt(Max[rt << 1 | 1]);
                Min[rt << 1 | 1] = sqrt(Min[rt << 1 | 1]);
                if (Max[rt << 1 | 1] == 1)
                    break;
            }
        if (Max[rt << 1 | 1] == Min[rt << 1 | 1])
            Sum[rt << 1 | 1] = Max[rt << 1 | 1] * (s >> 1);
        if (Max[rt << 1] == Min[rt << 1])
            Sum[rt << 1] = Max[rt << 1] * (s - (s >> 1));
        Sqr[rt] = 0;
    }
}
void buildtree(int l, int r, int rt)
{
    if (l == r)
    {
        scanf("%lld", &Min[rt]);
        Sum[rt] = Max[rt] = Min[rt];
        return;
    }
    int m = l + r >> 1;
    buildtree(lch);
    buildtree(rch);
    Pushup(rt);
}
void Update(int L, int R, int l, int r, int rt)
{
    if (L <= l && R >= r)
    {
        Sqr[rt] += 1;
        Max[rt] = sqrt(Max[rt]), Min[rt] = sqrt(Min[rt]);
        Sum[rt] = -1;
        if (Max[rt] == Min[rt])
            Sum[rt] = Max[rt] * (r - l + 1);
        return;
    }
    Sum[rt] = -1;
    Pushdown(rt, r - l + 1);
    int m = l + r >> 1;
    if (L <= m)
        Update(L, R, lch);
    if (R > m)
        Update(L, R, rch);
    Pushup(rt);
}
LL Query(int L, int R, int l, int r, int rt)
{
    if (L <= l && R >= r)
    {
        if (Max[rt] == Min[rt])
        {
            return Sum[rt] = Max[rt] * (r - l + 1);
        }
        if (Sum[rt] != -1)
            return Sum[rt];
    }
    Pushdown(rt, r - l + 1);
    LL ans = 0;
    int m = l + r >> 1;
    if (L <= m)
        ans += Query(L, R, lch);
    if (R > m)
        ans += Query(L, R, rch);
    return ans;
    Pushup(rt);
}
void print(int l, int r, int rt)
{
    printf("l=%d,r=%d,rt=%d,Sum[rt]=%lld\n", l, r, rt, Sum[rt]);
    if (l == r)
        return;
    int m = l + r >> 1;
    print(lch);
    print(rch);
}
int main()
{
    int n, m;
    //freopen("god.in", "r", stdin);
   // freopen("god.out", "w", stdout);
    scanf("%d", &n);
    buildtree(1, n, 1);
    scanf("%d", &m);
    int op, l, r;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &op, &l, &r);
        if (l > r)
            swap(l, r);
        if (op)
        {
            printf("%lld\n", Query(l, r, 1, n, 1));
        }
        else
        {
            Update(l, r, 1, n, 1);
        }
    }
#ifdef Mine
    //while (1)
        ;
#endif
}

String STL set map Trie

Tue, 11 Jul 2017 16:09:42 GMT

描述

硬盘中里面有n个文件，文件从1到n标号，每个文件可以用若干个数字序列来表示，而且每个文件存在一个重要值。现在请你完成一个搜索系统，有m 个搜索的操作，如果一个文件中有以这个数字序列为前缀的数字序列，那么这个文件会被搜索到，现在我们想知道会有多少个文件被搜索到，以及这些文件中重要值前k小的是哪些。

输入

第一行两个数n,m。接下来n行是对每个文件的描述（标号依次是1到n）：每行的前两个数字分别为描述这个文件的数字序列个数t和文件的重要值v。接下来有t组数。每组数先有一个数l，表示这个数字序列的长度。接下来有l个数，表示这个序列。接下来m行表示m个搜索操作：每行的前两个数字分别为搜索数k和前缀长度l。接下来l个数是这个前缀的数字序列。

输出

共m行。每行来表示搜索的结果：首先你需要输出有多少个文件会被搜索到。接下来你需要输出k个数，依次是重要值前k小的标号（根据重要值由小到大输出，重要值相同时，标号小的排在前面）。如果搜索到的文件数p比k小，那么你只需要输出p个,如果没有搜索到文件就不用输出了。

样例输入

5 5
1 1 5 1 2 3 4 5
1 2 5 1 2 4 5 3
1 8 5 2 1 4 3 2
1 9 5 2 1 8 5 2
1 1 5 1 2 3 4 5
2 2 1 2
3 2 1 2
4 2 1 2
4 2 2 1
1 2 2 1

样例输出

3 1 5
3 1 5 2
3 1 5 2
2 3 4
2 3

数据范围和约定

对于20%的数据
0<n,m<=50
每次询问k无限制
0<重要值<=10^9
0<数字序列中的数字<=10
所有文件数字序列长度之和<=500
所有询问前缀数字序列长度之和<=500
对于另外20%的数据
0<n,m<=50
每次询问k无限制
0<重要值<=10^9
0<数字序列中的数字<=10^9
所有文件数字序列长度之和<=500
所有询问前缀数字序列长度之和<=500
对于另外20%的数据
0<n,m<=510^4
每次询问k=1或k=2
0<重要值<=10^9
0<数字序列中的数字<=10
所有文件数字序列长度之和<=210^5
所有询问前缀数字序列长度之和<=2*10^5
对于剩下的数据
0<n,m<=510^4
每次询问k无限制
0<重要值<=10^9
0<数字序列中的数字<=10^9
所有文件数字序列长度之和<=210^5
所有询问前缀数字序列长度之和<=2*10^5

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <ctime>
using namespace std;
vector<int> l;
struct Improtant
{
    int i, Imp;
    bool operator<(const Improtant &a) const
    {
        return Imp == a.Imp ? i < a.i : Imp < a.Imp;
    }
} number[50005];
struct Trie
{
    map<int, Trie *> mp;
    set<Improtant> mark;
} * root;
void insert(int x)
{
    Trie *rt = root;
    rt->mark.insert(number[x]);
    for (int i = 0; i < l.size(); i++)
    {
        if (!rt->mp[l[i]])
            rt->mp[l[i]] = new Trie;
        rt = rt->mp[l[i]];
        rt->mark.insert(number[x]);
    }
}
void Query(int k)
{
    Trie *rt = root;
    for (int i = 0; i < l.size(); i++)
    {
        if (rt->mp[l[i]] == NULL)
        {
            printf("0\n");
            return;
        }
        rt = rt->mp[l[i]];
    }
    set<Improtant>::iterator it = rt->mark.begin();
    printf("%d ", rt->mark.size());
    for (int i = 1; i <= k && it != rt->mark.end(); i++, it++)
    {
        printf("%d ", it->i);
    }
    printf("\n");
    return;
}
int main()
{
#ifdef Mine
    freopen("1.in", "r", stdin);
#else
    freopen("string.in", "r", stdin);
#endif
    freopen("string.out", "w", stdout);
    int n, m;
    root = new Trie;
    scanf("%d%d", &n, &m);
    int t, s, a;
    for (int i = 1; i <= n; i++)
    {
        number[i].i = i;
        scanf("%d%d", &t, &number[i].Imp);
        while (t--)
        {
            scanf("%d", &s);
            l.clear();
            for (int j = 1; j <= s; j++)
            {
                scanf("%d", &a);
                l.push_back(a);
            }
            insert(i);
        }
    }
    int k;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &k, &s);
        l.clear();
        for (int j = 1; j <= s; j++)
        {
            scanf("%d", &a);
            l.push_back(a);
        }
        Query(k);
    }
    //printf("%lf",(double)clock()/CLOCKS_PER_SEC);
}

数学

Mon, 10 Jul 2017 15:52:42 GMT

组合数

$$ C(n,k)=\frac {n!} {(n-k)!k!} $$
$$ 0!=1 $$

$$ x^{p} mod p=x mod p $$
$$ x^{p-2} * x % p=1; $$

BZOJ 2120 数颜色

Sun, 09 Jul 2017 20:45:16 GMT

题目描述

墨墨购买了一套N支彩色画笔（其中有些颜色可能相同），摆成一排，你需要回答墨墨的提问。墨墨会像你发布如下指令： 1、 Q L R代表询问你从第L支画笔到第R支画笔中共有几种不同颜色的画笔。 2、 R P Col 把第P支画笔替换为颜色Col。为了满足墨墨的要求，你知道你需要干什么了吗？

输入

第1行两个整数N，M，分别代表初始画笔的数量以及墨墨会做的事情的个数。第2行N个整数，分别代表初始画笔排中第i支画笔的颜色。第3行到第2+M行，每行分别代表墨墨会做的一件事情，格式见题干部分。

输出

对于每一个Query的询问，你需要在对应的行中给出一个数字，代表第L支画笔到第R支画笔中共有几种不同颜色的画笔。

样例输入

6 5
1 2 3 4 5 5
Q 1 4
Q 2 6
R 1 2
Q 1 4
Q 2 6

样例输出

4
4
3
4

提示

对于100%的数据，N≤10000，M≤10000，修改操作不多于1000次，所有的输入数据中出现的所有整数均大于等于1且不超过10^6。 2016.3.2新加数据两组by Nano_Ape

题解

计算出 i 的前一个出现的位置
然后就和教主的魔法一样了
注意数组大小

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
int comp(int a, int b)
{
    return a > b;
}
using namespace std;
int pre[10005], front[1000005];
int in[10005];
int a[10005], b[10005];
int n, block;
void build(int x)
{
    for (int i = (x - 1) * block + 1; i <= min(x * block, n); i++)
    {
        pre[i] = b[i];
    }
    sort(pre + (x - 1) * block + 1, pre + min(x * block + 1, n + 1));
}
void rebuild(int k, int x)
{
    for (int i = 1; i <= n; i++)
        front[a[i]] = 0;
    a[k] = x;
    for (int i = 1; i <= n; i++)
    {
        int ls = b[i];
        b[i] = front[a[i]];
        if (ls != b[i])
            build(in[i]);
        front[a[i]] = i;
    }
}
int query(int c, int x)
{
    int l = (x - 1) * block + 1, r = min(n, x * block);
    int head = l;
    while (l <= r)
    {
        int m = (l + r) >> 1;
        if (pre[m] < c)
            l = m + 1;
        else
            r = m - 1;
    }
    return l - head;
}
int Query(int l, int r)
{
    int ans = 0;
    if (in[l] == in[r])
    {
        for (int i = l; i <= r; i++)
            if (b[i] < l)
                ans++;
    }
    else
    {
        for (int i = l; i <= min(block * in[l], n); i++)
            if (b[i] < l)
                ans++;
        for (int i = block * (in[r] - 1) + 1; i <= r; i++)
            if (b[i] < l)
                ans++;
    }
    for (int i = in [l] + 1; i < in[r]; i++)
        ans += query(l, i);
    return ans;
}
int main()
{
    //freopen("nt2011_color.in","r",stdin);
    //freopen("nt2011_color.out","w",stdout);
    //freopen("1.in", "r", stdin);
    int m;
    scanf("%d%d", &n, &m);
    block = sqrt(n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        b[i] = front[a[i]];
        front[a[i]] = i;
        in[i] = (i - 1) / block + 1;
    }
    int tot = in[n];
    for (int i = 1; i <= tot; i++)
        build(i);
    char s[10];
    int l, r;
    while (m--)
    {
        scanf("%s", s);
        if (s[0] == 'Q')
        {
            scanf("%d%d", &l, &r);
            printf("%d\n", Query(l, r));
        }
        else
        {
            scanf("%d%d", &l, &r);
            rebuild(l, r);
        }
    }
}

BZOJ 2724 [Violet 6] 蒲公英

Sun, 09 Jul 2017 20:36:54 GMT

题目描述

输入

修正一下

l = (l_0 + x - 1) mod n + 1, r = (r_0 + x - 1) mod n + 1

输出

样例输入

6 3
1 2 3 2 1 2
1 5
3 6
1 5

样例输出

1
2
1

修正下： n <= 40000, m <= 50000

题解

f(i,j)表示第 i 块到第 j 块的众数。为每一个数开vector<> 存他的位置
在求得时候二分就可以了
详见《区间众数解题报告 - 陈立杰》

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
using namespace std;
int n, m, block, tot;
int a[40005], Index, v[40005];
int in[40005];
int f[4000][4000], num[40005];
map<int, int> mp;
vector<int> x[40005];
void Init(int u)
{
    memset(num, 0, sizeof(num));
    int Max = 0, ans = 0;
    for (int i = (u - 1) * block + 1; i <= n; i++)
    {
        num[a[i]]++;
        if (num[a[i]] > Max || (num[a[i]] == Max && v[a[i]] < v[ans]))
            ans = a[i], Max = num[a[i]];
        f[u][in[i]] = ans;
    }
}
int Query(int l, int r, int u)
{
    return upper_bound(x[u].begin(), x[u].end(), r) - lower_bound(x[u].begin(), x[u].end(), l);
}
int Query(int l, int r)
{
    int ans, Max;
    ans = f[in[l] + 1][in[r] - 1];
    Max = Query(l, r, ans);
    for (int i = l; i <= min(in[l] * block, r); i++)
    {
        int now = Query(l, r, a[i]);
        if (now > Max || (now == Max && v[a[i]] < v[ans]))
            ans = a[i], Max = now;
    }
    if (in[l] != in[r])
    {
        for (int i = (in[r] - 1) * block + 1; i <= r; i++)
        {
            int now = Query(l, r, a[i]);
            if (now > Max || (now == Max && v[a[i]] < v[ans]))
                ans = a[i], Max = now;
        }
    }
    return ans;
}
int main()
{
    //freopen("input.in", "r", stdin);
    scanf("%d%d", &n, &m);
    block = 200;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        if (!mp[a[i]])
        {
            mp[a[i]] = ++Index;
            v[Index] = a[i];
        }
        a[i] = mp[a[i]];
        x[a[i]].push_back(i);
        in[i] = (i - 1) / block + 1;
    }
    tot = in[n];
    for (int i = 1; i <= tot; i++)
        Init(i);
    int l, r, ans = 0;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &l, &r);
        l = (l + ans - 1) % n + 1, r = (r + ans - 1) % n + 1;
        if (l > r)
            swap(l, r);
        ans = v[Query(l, r)];
        printf("%d\n", ans);
    }
    //while (1)
    ;
}

附数据生成器

#include<cstdio>  
#include<ctime>  
#include<cstdlib>  
#include<iostream>  
using namespace std;  
int main()  
{  
    freopen("input.in","w",stdout);  
    int n,m;  
    n=40000;m=50000;  
    srand(time(0));  
    printf("%d %d\n",n,m);  
    for (int i=1;i<=n;i++){  
        int x=rand()*rand()%1000000000+1;  
        cout<<x<<" ";  
    }  
    printf("\n");  
    for (int i=1;i<=m;i++){  
        int l=rand()*rand()%n+1;  
        int r=rand()*rand()%n+1;  
        cout<<l<<" "<<r<<endl;  
    }  
    return 0;  
}

BZOJ 2002 [Hnoi2010]Bounce 弹飞绵羊

Thu, 06 Jul 2017 17:16:03 GMT

题目描述

某天，Lostmonkey发明了一种超级弹力装置，为了在他的绵羊朋友面前显摆，他邀请小绵羊一起玩个游戏。游戏一开始，Lostmonkey在地上沿着一条直线摆上n个装置，每个装置设定初始弹力系数ki，当绵羊达到第i个装置时，它会往后弹ki步，达到第i+ki个装置，若不存在第i+ki个装置，则绵羊被弹飞。绵羊想知道当它从第i个装置起步时，被弹几次后会被弹飞。为了使得游戏更有趣，Lostmonkey可以修改某个弹力装置的弹力系数，任何时候弹力系数均为正整数。

输入

第一行包含一个整数n，表示地上有n个装置，装置的编号从0到n-1,接下来一行有n个正整数，依次为那n个装置的初始弹力系数。第三行有一个正整数m，接下来m行每行至少有两个数i、j，若i=1，你要输出从j出发被弹几次后被弹飞，若i=2则还会再输入一个正整数k，表示第j个弹力装置的系数被修改成k。对于20%的数据n,m<=10000，对于100%的数据n<=200000,m<=100000

输出

对于每个i=1的情况，你都要输出一个需要的步数，占一行。

样例输入

4
1 2 1 1
3
1 1
2 1 1
1 1

样例输出

2
3

题解

将每一块都处理出
i 跳出这一块所用的次数和跳到的位置然后更新时将这一块重构

细节有问题的代码也能过（气）

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch > '9' || ch < '0')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}
int n, m, k[200005], block;
int in[200005], next[200005], times[200005], l[200005];
int main()
{
    //freopen("1.in","r",stdin);
    //scanf("%d", &n);
    n = read();
    block = sqrt(n);
    for (int i = 0; i < n; i++)
    {
        k[i] = read();
        //scanf("%d", k + i);
        in[i] = i / block + 1;
        l[i] = (in[i] - 1) * block;
    }
    for (int i = n - 1; i >= 0; i--)
    {
        if (i + k[i] > n)
        {
            times[i] = 1;
            next[i] = n;
        }
        else if (in[i] == in[i + k[i]])
        {
            times[i] = times[i + k[i]] + 1;
            next[i] = next[i + k[i]];
        }
        else
        {
            times[i] = 1;
            next[i] = i + k[i];
        }
    }
    //scanf("%d", &m);
    m = read();
    int op, s;
    while (m--)
    {
        //scanf("%d", &op);
        op = read();
        if (op == 1)
        {
            //scanf("%d", &s);
            s = read();
            int ans = 0;
            for (int i = s; i < n; i = next[i])
            {
                ans += times[i];
            }
            printf("%d\n", ans);
        }
        else
        {
            //scanf("%d%d", &s, &c);
            //k[s] = c;
            s = read();
            k[s] = read();
            for (int i = s; i >= l[s]; i--)
            {
                if (i + k[i] > n)
                {
                    times[i] = 1;
                    next[i] = i + k[i];
                }
                if (in[i] == in[i + k[i]])
                {
                    times[i] = times[i + k[i]] + 1;
                    next[i] = next[i + k[i]];
                }
                else
                {
                    times[i] = 1;
                    next[i] = i + k[i];
                }
            }
        }
    }
}

Codeforces 743E Vladik and cards

Mon, 03 Jul 2017 16:30:22 GMT

题目描述

Vladik在回家的路上无聊，决定玩下面的游戏：他拿了n张牌在他面前排成一个序列，每张牌上都有一个不超过8的正整数，他决定找到满足以下条件的牌的最长子序列：

在这个序列中,[1,8]每个数字出现的次数之差的绝对值不超过1;
相同的数字必须连续，输出最长子序列的长度。例如，子序列[1, 1, 2, 2]满足第2个条件，但是子序列 [1, 2, 2, 1]就不满足(注意，子序列[1, 1, 2, 2]不满足第一个条件)。  请帮助Vladik找到满足这两个条件的最长子序列的长度。

输入

第一行包含单个整数n（1≤n≤1000） - Vladik序列中的牌数。

第二行包含不超过8的n个正整数的序列 - 每个数空格隔开

输出

输出一个整数，即满足两个条件的子序列的最大长度

样例输入

sample input 1:

3
1 1 1

sample input 2:

8
8 7 6 5 4 3 2 1

sample input 3:

24
1 8 1 2 8 2 3 8 3 4 8 4 5 8 5 6 8 6 7 8 7 8 8 8

样例输出

sample output 1:
1
sample output 2:
8
sample output 3:
17

题解请参考CodeForces743E. Vladik and cards 二分+装压dp

/*
 * @Author: WildRage 
 * @Date: 2017-07-02 16:07:15 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-07-02 17:58:06
 */
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int a[1005], sum[10][1005],n;
int DP[1005][300];
bool had[10];
int N = (1 << 8) - 1;
vector<int> in[10];
int get_num(int p, int len)
{
	int now = lower_bound(in[a[p]].begin(), in[a[p]].end(), p) - in[a[p]].begin();
	int ans = now + len - 1;
	if (in[a[p]].size() - 1 < ans)
		return -1;
	return in[a[p]][ans];
}
int Judge(int len)
{
	memset(DP, 0, sizeof(DP));
	for (int i = 0; i < n; i++)
	{
		int to = get_num(i + 1, len);
		if (to != -1)
			DP[to][(1 << (a[i + 1] - 1))] = max(DP[i][0] + len, DP[to][1 << (a[i + 1] - 1)]);
		to = get_num(i + 1, len + 1);
		if (to != -1)
			DP[to][(1 << (a[i + 1] - 1))] = max(DP[i][0] + len + 1, DP[to][(1 << (a[i + 1] - 1))]);
		for (int j = 1; j < N; j++)
		{
			if (DP[i][j])
			{
				DP[i + 1][j] = max(DP[i + 1][j], DP[i][j]);
				if (j & (1 << (a[i + 1] - 1)))
					continue;
				to = get_num(i + 1, len);
				if (to != -1)
					DP[to][j | (1 << (a[i + 1] - 1))] = max(DP[i][j] + len, DP[to][j | (1 << (a[i + 1] - 1))]);
				to = get_num(i + 1, len + 1);
				if (to != -1)
					DP[to][j | (1 << (a[i + 1] - 1))] = max(DP[i][j] + len + 1, DP[to][j | (1 << (a[i + 1] - 1))]);
			}
			DP[i + 1][N] = max(DP[i + 1][N], DP[i][N]);
		}
	}
	return DP[n][N];
}
int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", a + i);
		had[a[i]] = 1;
		in[a[i]].push_back(i);
	}
	int ans = 0;
	for(int i=1;i<=8;i++)if(had[i])ans++;
	int l = 1, r = 256;
	while (l <= r)
	{
		int mid = l + r >> 1;
		int x = Judge(mid);
		ans = max(x, ans);
		if (x)
			l = mid + 1;
		else
			r = mid - 1;
	}
	printf("%d", ans);
}

HDU 1166 敌兵布阵

Mon, 03 Jul 2017 16:30:22 GMT

题目描述

C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。

中央情报局要研究敌人究竟演习什么战术,所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人,例如Derek问:“Tidy,马上汇报第3个营地到第10个营地共有多少人!”Tidy就要马上开始计算这一段的总人数并汇报。但敌兵营地的人数经常变动，而Derek每次询问的段都不一样，所以Tidy不得不每次都一个一个营地的去数，很快就精疲力尽了，Derek对Tidy的计算速度越来越不满:"你个死肥仔，算得这么慢，我炒你鱿鱼!”Tidy想：“你自己来算算看，这可真是一项累人的工作!我恨不得你炒我鱿鱼呢!”无奈之下，Tidy只好打电话向计算机专家Windbreaker求救,Windbreaker说：“死肥仔，叫你平时做多点acm题和看多点算法书，现在尝到苦果了吧!”Tidy说："我知错了。。。"但Windbreaker已经挂掉电话了。Tidy很苦恼，这么算他真的会崩溃的，聪明的读者，你能写个程序帮他完成这项工作吗？不过如果你的程序效率不够高的话，Tidy还是会受到Derek的责骂的.

输入

第一行一个整数T，表示有T组数据。每组数据第一行一个正整数N（N<=50000）,表示敌人有N个工兵营地，接下来有N个正整数,第i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=50）。接下来每行有一条命令，命令有4种形式： (1) Add i j,i和j为正整数,表示第i个营地增加j个人（j不超过30） (2)Sub i j ,i和j为正整数,表示第i个营地减少j个人（j不超过30）; (3)Query i j ,i和j为正整数,i<=j，表示询问第i到第j个营地的总人数; (4)End 表示结束，这条命令在每组数据最后出现; 每组数据最多有40000条命令

输出

对第i组数据,首先输出“Case i:”和回车, 对于每个Query询问，输出一个整数并回车,表示询问的段中的总人数,这个数保持在int以内。

样例输入

1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End

样例输出

Case 1:
6
33
59

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
namespace MineWorkSpace
{
int n;
class Block_Main
{
    int block, n;
    int a[50005], in[50005], sum[305];

  public:
    void Init(int N)
    {
        memset(in, 0, sizeof(in));
        memset(sum, 0, sizeof(sum));
        memset(a, 0, sizeof(a));
        n = N;
        block = sqrt(n);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", a + i);
            in[i] = (i - 1) / block + 1;
            sum[in[i]] += a[i];
        }
    }
    void Updata(int i, int c)
    {
        a[i] += c;
        sum[in[i]] += c;
    }
    int Query(int l, int r)
    {
        int ans = 0;
        if (in[l] == in[r])
        {
            for (int i = l; i <= r; i++)
                ans += a[i];
            return ans;
        }
        else
        {
            for (int i = in [l] + 1; i <= in[r] - 1; i++)
                ans += sum[i];
            for (int i = l; i <= in[l] * block; i++)
                ans += a[i];
            for (int i = (in[r] - 1) * block + 1; i <= r; i++)
                ans += a[i];
            return ans;
        }
    }
} Block;
class Order_run
{
    int l, r;

  public:
    void Run(char c)
    {
        if (c == 'Q')
        {
            scanf("%d%d", &l, &r);
            if (l > r)
                printf("0\n");
            else
                printf("%d\n", Block.Query(l, r));
            return;
        }
        if (c == 'A')
        {
            scanf("%d%d", &l, &r);
            Block.Updata(l, r);
            return;
        }
        if (c == 'S')
        {
            scanf("%d%d", &l, &r);
            Block.Updata(l, -r);
            return;
        }
    }
} Order;
class Main
{
  public:
    Main()
    {
        int T;
        scanf("%d", &T);
        for (int L = 1; L <= T; L++)
        {
            printf("Case %d:\n", L);
            scanf("%d", &n);
            Block.Init(n);
            char s[10];
            while (1)
            {
                scanf("%s", s);
                if (s[0] == 'E')
                    break;
                Order.Run(s[0]);
            }
        }
    }
} run;
}
int main() { ; }

POJ 2185 Milking Grid

Mon, 03 Jul 2017 16:12:51 GMT

Description

Every morning when they are milked, the Farmer John's cows form a rectangular grid that is R (1 <= R <= 10,000) rows by C (1 <= C <= 75) columns. As we all know, Farmer John is quite the expert on cow behavior, and is currently writing a book about feeding behavior in cows. He notices that if each cow is labeled with an uppercase letter indicating its breed, the two-dimensional pattern formed by his cows during milking sometimes seems to be made from smaller repeating rectangular patterns.  Help FJ find the rectangular unit of smallest area that can be repetitively tiled to make up the entire milking grid. Note that the dimensions of the small rectangular unit do not necessarily need to divide evenly the dimensions of the entire milking grid, as indicated in the sample input below.

Input

Line 1: Two space-separated integers: R and C
Lines 2..R+1: The grid that the cows form, with an uppercase letter denoting each cow's breed. Each of the R input lines has C characters with no space or other intervening character.

Output

Line 1: The area of the smallest unit from which the grid is formed

Sample Input

2 5
ABABA
ABABA

Sample Output

2

题解

要求循环节，想到"POJ 2406 Power Strings"
把情况拓展到二维
对于每一个横行求最短循环节也就是m-next[m]
然后不断的求lcm
竖列也是一样
最后乘起来就可以了
不过在求lcm时如果大于边界就可以将他的值给为边界

/*
 * @Author: WildRage 
 * @Date: 2017-07-01 10:17:47 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-07-01 11:08:00
 */
#include<iostream>
#include<cstdio>
#include<cstring>
namespace MineWorkSpace{
	char s[10005][80];
	int next[10005][80];
	int next2[80][10005];
	int gcd(int a,int b){
		return b==0? a: gcd(b,a%b);
	}
	int lcm(int a,int b){
		return a/gcd(a,b)*b;
	}
	int Main()
	{
	#ifdef Mine
	    freopen("mgrid.in","r",stdin);
	    freopen("mgrid.out","w",stdout);
	#endif
		int n,m;
		scanf("%d%d",&n,&m);
		for(int i=0;i<n;i++){
			scanf("%s",s[i]);
		}
		int ans1=1,ans2=1;
		for(int i=0;i<n;i++){
			int j=0,k=-1;
			next[i][0]=-1;
			while(j<m){
				if(k==-1||s[i][j]==s[i][k]){
					next[i][++j]=++k;
				}
				else k=next[i][k];
			}
			if(m-next[i][m]) ans1=lcm(ans1,m-next[i][m]);
			if(ans1>m)ans1=m;
		}
		for(int i=0;i<m;i++){
			int j=0,k=-1;
			next2[i][0]=-1;
			while(j<n){
				if(k==-1||s[j][i]==s[k][i]){
					next2[i][++j]=++k;
				}
				else k=next2[i][k];
			}
			if(n-next2[i][n])ans2=lcm(ans2,n-next2[i][n]);
			if(ans2>n)ans2=n;
		}
		return printf("%d",ans1*ans2);
	}
}
int main()
{
	MineWorkSpace::Main();
	//while(1);
}

BZOJ 4720 [NOIP2016]换教室

Sun, 25 Jun 2017 16:46:30 GMT

Description

对于刚上大学的牛牛来说,他面临的第一个问题是如何根据实际情况申请合适的课程。在可以选择的课程中,有2n节课程安排在n个时间段上。在第i(1≤i≤n)个时间段上,两节内容相同的课程同时在不同的地点进行,其中,牛牛预先被安排在教室ci上课,而另一节课程在教室di进行。在不提交任何申请的情况下,学生们需要按时间段的顺序依次完成所有的n节安排好的课程。如果学生想更换第i节课程的教室,则需要提出申请。若申请通过,学生就可以在第i个  时间段去教室di上课,否则仍然在教室ci上课。由于更换教室的需求太多,申请不一定能获得通过。通过计算,牛牛发现申请更换第i节课程的教室时,申请被通过的概率是一个已知的实数ki,并且对于不同课程的申请,被通过的概率是互相独立的。学校规定,所有的申请只能在学期开始前一次性提交,并且每个人只能选择至多m节课程进行申请。这意味着牛牛必须一次性决定是否申请更换每节课的教室,而不能根据某些课程的申请结果来决定其他课程是否申请;牛牛可以申请自己最希望更换教室的m门课程,也可以不用完这m个申请的机会,甚至可以一门课程都不申请。因为不同的课程可能会被安排在不同的教室进行,所以牛牛需要利用课间时间从一间教室赶到另一间教室。牛牛所在的大学有v个教室,有e条道路。每条道路连接两间教室,并且是可以双向通行的。由于道路的长度和拥堵程度不同, 通过不同的道路耗费的体力可能会有所不同。当第i(1≤i≤n-1)节课结束后,牛牛就会从这节课的教室出发,选择一条耗费体力最少的路径前往下一节课的教室。现在牛牛想知道,申请哪几门课程可以使他因在教室间移动耗费的体力值的总和的期望值最小,请你帮他求出这个最小值。

Output

输出一行,包含一个实数,四舎五入精确到小数点后恰好2位,表示答案。你的输出必须和标准输出完全一样才算正确。测试数据保证四舎五入后的答案和准确答案的差的绝对值不大于4*10^-3。(如果你不知道什么是浮点误差,这段话可以理解为:对于大多数的算法,你可以正常地使用浮点数类型而不用对它进行特殊的处理)

Sample Input

3 2 3 3
2 1 2
1 2 1
0.8 0.2 0.5
1 2 5
1 3 3
2 3 1

Sample Output

2.80

题解

这道题相比于前几道题是真水
先跑一下 Floyd 根据期望的可加性只要在算DP数组的时候不断的加就可以了
分四种情况讨论
然后交上去就WA了再一看要保留2位小数我保留了3位
另外能把程序写的这么宽的人也只有我了吧

/*
 * @Author: WildRage 
 * @Date: 2017-06-25 15:42:08 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-06-25 16:28:13
 */
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
namespace WorkSpace{
    class Floyd{
        int n;
        int a[305][305];
    public:
        void GetMinDis(){
            for(int i=1;i<=n;i++) a[i][i]=0;
            for(int k=1;k<=n;k++)
                for(int i=1;i<=n;i++)
                    for(int j=1;j<=n;j++)
                        a[i][j]=std::min(a[i][j],a[i][k]+a[k][j]);
        }
        void GetMap(int Number=0,int m=0){
            n=Number;
            memset(a,0x3f,sizeof(a));
            int s,e,v;
            for(int i=1;i<=m;i++){
                scanf("%d%d%d",&s,&e,&v);
                a[s][e]=std::min(v,a[s][e]);
                a[e][s]=std::min(v,a[s][e]);
            }
        }
        int MinDis(int s=0,int e=0){
            return a[s][e];
        }
    }Map;
    struct Input{
        int n,m,v,e;
    }Read;
    int ClassroomC[2005],ClassroomD[2005];
    double ChangeProbability[2005],FailedToChange[2005];
    class Init{
        void OpenFile(){
            freopen("classrooma.in","r",stdin);
            freopen("classrooma.out","w",stdout);
        }
        void ReadInput(){
            scanf("%d%d%d%d",&Read.n,&Read.m,&Read.v,&Read.e);
            for(int i=1;i<=Read.n;i++) scanf("%d",&ClassroomC[i]);
            for(int i=1;i<=Read.n;i++) scanf("%d",&ClassroomD[i]);
            for(int i=1;i<=Read.n;i++) scanf("%lf",&ChangeProbability[i]),FailedToChange[i]=1-ChangeProbability[i];
            Map.GetMap(Read.v,Read.e);
        }
    public:
        Init(){
        #ifdef MineWorkSpace
            OpenFile();
        #endif
            ReadInput();
            Map.GetMinDis();
        }
    };
    class DP{
        double MinExpectation[2010][2010][2];
    public:
        #define n Read.n
        #define m Read.m
        DP(){
            memset(MinExpectation,0x43,sizeof(MinExpectation));
            MinExpectation[1][0][0]=0;MinExpectation[1][1][1]=0;
            for(int i=2;i<=n;i++){
                for(int j=0;j<=m;j++){
                    MinExpectation[i][j][0]=std::min(MinExpectation[i-1][j][0]+Map.MinDis(ClassroomC[i-1],ClassroomC[i]),MinExpectation[i-1][j][1]+(double)Map.MinDis(ClassroomD[i-1],ClassroomC[i])*ChangeProbability[i-1]+(double)Map.MinDis(ClassroomC[i-1],ClassroomC[i])*FailedToChange[i-1]);
                    if(j>0)MinExpectation[i][j][1]=std::min(MinExpectation[i-1][j-1][0]+(double)Map.MinDis(ClassroomC[i-1],ClassroomD[i])*ChangeProbability[i]+(double)Map.MinDis(ClassroomC[i-1],ClassroomC[i])*FailedToChange[i],MinExpectation[i-1][j-1][1]+(double)Map.MinDis(ClassroomC[i-1],ClassroomC[i])*FailedToChange[i-1]*FailedToChange[i]+(double)Map.MinDis(ClassroomC[i-1],ClassroomD[i])*FailedToChange[i-1]*ChangeProbability[i]+(double)Map.MinDis(ClassroomD[i-1],ClassroomC[i])*ChangeProbability[i-1]*FailedToChange[i]+Map.MinDis(ClassroomD[i-1],ClassroomD[i])*ChangeProbability[i-1]*ChangeProbability[i]);
                }
            }
            double ans=1e16;
            for(int i=0;i<=m;i++){
                ans=std::min(MinExpectation[n][i][0],ans);
                ans=std::min(MinExpectation[n][i][1],ans);
            }
            printf("%.2lf",ans);
        }    
    };
    class Main{
    public:
        Main(){
            new Init();
            new DP();
            //while(1);
        }
    }Run;
}
int main(){;}

BZOJ 1076 [SCOI2008]奖励关

Sat, 24 Jun 2017 09:48:46 GMT

Description

你正在玩你最喜欢的电子游戏，并且刚刚进入一个奖励关。在这个奖励关里，系统将依次随机抛出k次宝物，每次你都可以选择吃或者不吃（必须在抛出下一个宝物之前做出选择，且现在决定不吃的宝物以后也不能再吃）。宝物一共有n种，系统每次抛出这n种宝物的概率都相同且相互独立。也就是说，即使前k-1次系统都抛出宝物1（这种情况是有可能出现的，尽管概率非常小），第k次抛出各个宝物的概率依然均为1/n。获取第i种宝物将得到Pi 分，但并不是每种宝物都是可以随意获取的。第i种宝物有一个前提宝物集合Si。只有当Si中所有宝物都至少吃过  一次，才能吃第i种宝物（如果系统抛出了一个目前不能吃的宝物，相当于白白的损失了一次机会）。注意，Pi可以是负数，但如果它是很多高分宝物的前提，损失短期利益而吃掉这个负分宝物将获得更大的长期利益。假设你采取最优策略，平均情况你一共能在奖励关得到多少分值？

Input

第一行为两个正整数k和n，即宝物的数量和种类。以下n行分别描述一种宝物，其中第一个整数代表分值，随后的整数依次代表该宝物的各个前提宝物（各宝物编号为1到n），以0结尾。

Output

输出一个实数，保留六位小数，即在最优策略下平均情况的得分。

Sample Input

1 2
1 0
2 0

Sample Output

1.500000

题解

逆推即可
水题

#include<iostream>
#include<cstdio>
using namespace std;
int w[16];
int p[16];
double f[105][1<<15];
int main()
{
    int n,k;
    scanf("%d%d",&k,&n);
    int a;
    for(int i=1;i<=n;i++){
        scanf("%d",&w[i]);
        while(scanf("%d",&a)&&a!=0) p[i]|=1<<(a-1);
    }
    int S=(1<<n)-1;
    for(int i=k;i>=1;i--){
        for(int j=0;j<=S;j++){
            for(int m=1;m<=n;m++)
                if((p[m]&j)==p[m])
                    f[i][j]+=max(f[i+1][j],f[i+1][j|(1<<(m-1))]+w[m]);
                else f[i][j]+=f[i+1][j];
            f[i][j]/=n;
        }
    }
    printf("%.6lf",f[1][0]);
}

BZOJ 2337 [HNOI2011]XOR和路径

Thu, 22 Jun 2017 17:05:22 GMT

Description

题解

以每一位分别分析
f[i]为这一位为1的概率

然后高斯消元即可

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct edge{
    int END,next;
    bool b[32];
}v[30005];
int first[105],p,t[105],du[105];
double f[105][35][2];
double a[105][105],x[105];
void add(int a,int b,int c){
    int i=1;
    du[a]++;
    while(c){
        v[p].b[i]=c&1;
        i++;c>>=1;
    }
    v[p].END=b;v[p].next=first[a];
    first[a]=p++;
}
int n,m;
void gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++){
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        }
        if(im!=k){
            for(int i=k;i<=n+1;i++){
                swap(a[num][i],a[im][i]);
            }
        }
        if(!a[num][k]){
            num--;continue;
        }
        for(int i=num+1;i<=n;i++){
            if(!a[num][k])continue;
            long double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++){
                a[i][j]-=t*a[k][j];
            }
        }
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--){
            a[i][n+1]-=a[i][j]*x[j];
        }
        x[i]=a[i][n+1]/a[i][i];
    }
}
int main()
{
    //freopen("xorpath.in", "r", stdin);
    //freopen("xorpath.out", "w", stdout);
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    for(int a1,b,c,i=1;i<=m;i++){
        scanf("%d%d%d",&a1,&b,&c);
        add(a1,b,c);
        if(a1!=b) add(b,a1,c);
    }
    //for(int i=first[n];i!=-1;i=v[i].next)
     //   rdu[v[i].END]--;
    long double ans=0;
    for(int k=1;k<=31;k++){
        memset(a,0,sizeof(a));
        for(int i=1;i<n;i++){
            a[i][i]=1;
            memset(t,0,sizeof(t));
            for(int j=first[i];j!=-1;j=v[j].next){
                //if(v[j].END==n)continue;
                if(v[j].b[k]) a[i][v[j].END]+=double(1)/du[i],a[i][n+1]+=(double)1/du[i];
                else a[i][v[j].END]-=double(1)/du[i];
            }
        }
        a[n][n]=1;
        gauss();
        ans+=x[1]*(1<<(k-1));
    }
    printf("%.3lf",(double)ans);
}

莫比乌斯反演的证明

Wed, 21 Jun 2017 18:00:21 GMT

莫比乌斯反演

已知 $$ F(n)=\sum_{d|n}{f(d)} $$ 则
$$ f(n)=\sum_{d|n}{\mu(d)F(\frac {n}{d})} $$  证明 $$ \sum_{d|n}{\mu(d)F(\frac {n}{d})} $$ $$ =\sum_{d|n}{\mu(d)\sum_{d'|\frac {n}{d}}{f(d')}} $$

未完待续

BZOJ 1415 [Noi2005] 聪聪和可可概率DP

Wed, 21 Jun 2017 17:43:55 GMT

Description

Input

数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

Output

输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

Sample Input

【输入样例1】
4 3
1 4
1 2
2 3
3 4
【输入样例2】
9 9
9 3
1 2
2 3
3 4
4 5
3 6
4 6
4 7
7 8
8 9

Sample Output

【输出样例1】
1.500
【输出样例2】
2.167

题解

先每个点跑一遍SPFA
求出p[i][j]表示当可可在 j 点时，聪聪在 i 点要走的下一步
然后记忆化搜索
$$ f[s][e]=\sum_{tmp=p[p[i][e]][e],e->j}{\frac{f[tmp][j]}{du[e]+1}} $$

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct edge{
    int END,next;
}v[100005];
int first[1005],Index,du[1005],n;
void add(int a,int b){
    du[a]++;
    v[Index].END=b;
    v[Index].next=first[a];
    first[a]=Index++;
}
int p[1005][1005];
double f[1005][1005];
void spfa(int x){
    queue<int> Q;
    bool flag[1005]={0};
    int dis[1005],fr[1005];
    memset(dis,0x3f,sizeof(dis));
    memset(fr,0,sizeof(fr));
    dis[x]=0;
    flag[x]=1;Q.push(x);
    while(!Q.empty()){
        int k=Q.front();
        Q.pop();flag[k]=0;
        for(int i=first[k];i!=-1;i=v[i].next){
            if(dis[v[i].END]>dis[k]+1||(dis[v[i].END]==dis[k]+1&&k<fr[v[i].END])){
                dis[v[i].END]=dis[k]+1;
                fr[v[i].END]=k;
                if(!flag[v[i].END]){
                    flag[v[i].END]=1;
                    Q.push(v[i].END);
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
        if(i!=x)
            p[i][x]=fr[i];
}
double dfs(int s,int e){
    if(s==e)return f[s][e]=0;
    if(p[s][e]==e||p[p[s][e]][e]==e)return f[s][e]=1;
    if(f[s][e]<=1e9) return f[s][e];
    int tmp=p[p[s][e]][e];
    f[s][e]=1;
    for(int i=first[e];i!=-1;i=v[i].next){
        f[s][e]+=dfs(tmp,v[i].END)/(du[e]+1);
    }
    f[s][e]+=dfs(tmp,e)/(du[e]+1);
    return f[s][e];
}
int main()
{
    //freopen("cchkk.in","r",stdin);
	//freopen("cchkk.out","w",stdout);
    memset(first,-1,sizeof(first));
    memset(f,0x7f,sizeof(f));
    int m,s,e,a,b;
    scanf("%d%d%d%d",&n,&m,&s,&e);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    for(int i=1;i<=n;i++)
        spfa(i);
    printf("%.3lf",dfs(s,e));
    //while(1);
}

BZOJ 3143 [Hnoi2013]游走高斯消元概率DP

Wed, 21 Jun 2017 15:53:46 GMT

Description

一个无向连通图，顶点从1编号到N，边从1编号到M。小Z在该图上进行随机游走，初始时小Z在1号顶点，每一步小Z以相等的概率随机选择当前顶点的某条边，沿着这条边走到下一个顶点，获得等于这条边的编号的分数。当小Z 到达N号顶点时游走结束，总分为所有获得的分数之和。现在，请你对这M条边进行编号，使得小Z获得的总分的期望值最小。

Input

第一行是正整数N和M，分别表示该图的顶点数和边数，接下来M行每行是整数u，v(1≤u,v≤N)，表示顶点u与顶点v之间存在一条边。输入保证30%的数据满足N≤10，100%的数据满足2≤N≤500且是一个无向简单连通图。

Output

仅包含一个实数，表示最小的期望值，保留3位小数。

Sample Input

3 3
2 3
1 2
1 3

Sample Output

3.333

题解

用贪心的思想
要使期望最小那么可以先求出每条边的期望经过次数
然后问题就转化成了求每条边的期望经过次数
可能从u走到v,也可能从v走到u,从u走到v的期望次数等于经过点u的次数/u的度数
这样就转化成了每个点的期望经过次数
易得
$$ f[1]=1+\sum_{j!=n}{f[j]/degree(j)} $$
$$ f[i]=\sum_{j!=n}{f[j]/degree(j)} (i!=n) $$

这样就建立了一个n-1元方程组

高斯消元解就可以了

代码比较丑

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
struct edge{
    int END,next;
}v[500005];
int first[505],p,du[505];
void add(int a,int b){
    v[p].END=b;
    v[p].next=first[a];
    first[a]=p++;
}
template<typename T>
int cmp(const T a,const T b){
    return a > b;
}
double a[505][505],x[505],f[500005];
int n,m;
void gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++)
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        if(im!=k){
            for(int i=k;i<=n+1;i++)
                swap(a[num][i],a[im][i]);
        }
        if(!a[num][k]){
            num--;continue;
        }
        for(int i=num+1;i<=n;i++){
            if(!a[num][i])continue;
            double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++){
                a[i][j]-=t*a[k][j];
            }
        }
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--){
            a[i][n+1]-=a[i][j]*x[j];
        }
        x[i]=a[i][n+1]/a[i][i];
    }
}
int main()
{
    //freopen("walk.in","r",stdin);
	//freopen("walk.out","w",stdout);
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    int s,e;
    for(int i=1;i<=m;i++){
        scanf("%d%d",&s,&e);
        du[s]++;du[e]++;
        add(s,e);add(e,s);
    }
    n--;
    a[1][n+1]=-1;
    for(int i=1;i<=n;i++){
        a[i][i]=-1;
        for(int j=first[i];j!=-1;j=v[j].next){
            if(v[j].END!=n+1)
                a[i][v[j].END]+=(double)1/(du[v[j].END]);
        }
    }
    gauss();
    for(int i=0;i<p;i++){
        //if(v[i].END!=n+1)
            f[i>>1]+=x[v[i].END]/du[v[i].END];
    }
    //for(int i=0;i<m;i++){
    //    printf("%lf\n",f[i+1]);
    //}
    //while(1);
    sort(f,f+m,cmp<double>);
    double ans=0;
    for(int i=0;i<m;i++){
        ans+=f[i]*(i+1);
    }
    printf("%.3lf",ans);
    //while(1);
}

BZOJ 1778 [Usaco2010 Hol] Dotp 驱逐猪猡高斯消元概率期望

Mon, 19 Jun 2017 17:12:36 GMT

Description

奶牛们建立了一个随机化的臭气炸弹来驱逐猪猡。猪猡的文明包含1到N (2 <= N <= 300)一共N个猪城。这些城市由M (1 <= M <= 44,850)条由两个不同端点A_j和B_j (1 <= A_j<= N; 1 <= B_j <= N)表示的双向道路连接。保证城市1至少连接一个其它的城市。一开始臭气弹会被放在城市1。每个小时（包括第一个小时），它有P/Q (1 <= P <=1,000,000; 1 <= Q <= 1,000,000)的概率污染它所在的城市。如果这个小时内它没有污染它所在的城市，那麽它随机地选择一条道路，在这个小时内沿着这条道路走到一个新的城市。可以离开这个城市的所有道路被选择的概率均等。因为这个臭气弹的随机的性质，  奶牛们很困惑哪个城市最有可能被污染。给定一个猪猡文明的地图和臭气弹在每个小时内爆炸的概率。计算每个城市最终被污染的概率。如下例，假设这个猪猡文明有两个连接在一起的城市。臭气炸弹从城市1出发，每到一个城市，它都有1/2的概率爆炸。 1--2 可知下面这些路径是炸弹可能经过的路径（最后一个城市是臭气弹爆炸的城市）： 1: 1 2: 1-2 3: 1-2-1 4: 1-2-1-2 5: 1-2-1-2-1 ... 要得到炸弹在城市1终止的概率，我们可以把上面的第1，第3，第5……条路径的概率加起来，（也就是上表奇数编号的路径）。上表中第k条路径的概率正好是(1/2)^k，也就是必须在前k-1个回合离开所在城市（每次的概率为1 - 1/2 = 1/2）并且留在最后一个城市（概率为1/2）。所以在城市1结束的概率可以表示为1/2 + (1/2)^3 + (1/2)^5 + ...。当我们无限地计算把这些项一个个加起来，我们最后会恰好得到2/3，也就是我们要求的概率，大约是0.666666667。这意味着最终停留在城市2的概率为1/3，大约为0.333333333。

Input

第1行: 四个由空格隔开的整数: N, M, P, 和 Q * 第2到第M+1行: 第i+1行用两个由空格隔开的整数A_j和B_j表示一条道路。

Output

第1到第N行: 在第i行，用一个浮点数输出城市i被摧毁的概率。误差不超过10^-6的答桉会被接受（注意这就是说你需要至少输出6位有效数字使得答桉有效）。

Sample Input

2 1 1 2
1 2

Sample Output

0.666666667
0.333333333

题解

既可以从概率的方向思考
也可以从期望的角度考虑

期望

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int mp[305][305],du[305],n;
long double a[305][305],x[305],sum;
void gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++){
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        }
        if(im!=k){
            for(int i=k;i<=n+1;i++)
                swap(a[num][i],a[im][i]);
        }
        if(!a[num][k]){
            num--;continue;
        }
        for(int i=num+1;i<=n;i++){
            if(!a[num][k])continue;
            long double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++){
                a[i][j]-=t*a[k][j];
            }
        }
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--){
            a[i][n+1]-=a[i][j]*x[j];
        }
        x[i]=a[i][n+1]/a[i][i];
        sum+=x[i];
    }
}
int main()
{
    freopen("dotp.in","r",stdin);
    freopen("dotp.out","w",stdout);
    int m,p,q,s,e;
    scanf("%d%d%d%d",&n,&m,&p,&q);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&s,&e);
        mp[s][e]++;mp[e][s]++;
        du[s]++;du[e]++;
    }
    a[1][n+1]=1;
    for(int i=1;i<=n;i++){
        a[i][i]=1;
        for(int j=1;j<=n;j++){
            if(mp[i][j]){
                a[i][j]+=((long double)p/q-1)/du[j]*mp[i][j];
            }
        }
    }
    gauss();
    for(int i=1;i<=n;i++){
        printf("%.9lf\n",(double)(x[i]/sum));
    }
    //while(1);
}

概率

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int mp[305][305],du[305],n;
long double a[305][305],x[305];
void gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++){
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        }
        if(im!=k){
            for(int i=k;i<=n+1;i++)
                swap(a[num][i],a[im][i]);
        }
        if(!a[num][k]){
            num--;continue;
        }
        for(int i=num+1;i<=n;i++){
            if(!a[num][k])continue;
            long double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++){
                a[i][j]-=t*a[k][j];
            }
        }
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--){
            a[i][n+1]-=a[i][j]*x[j];
        }
        x[i]=a[i][n+1]/a[i][i];
    }
}
int main()
{
    freopen("dotp.in","r",stdin);
    freopen("dotp.out","w",stdout);
    int m,p,q,s,e;
    scanf("%d%d%d%d",&n,&m,&p,&q);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&s,&e);
        mp[s][e]++;mp[e][s]++;
        du[s]++;du[e]++;
    }
    a[1][n+1]=1;
    for(int i=1;i<=n;i++){
        a[i][i]=1;
        for(int j=1;j<=n;j++){
            if(mp[i][j]){
                a[i][j]+=((long double)p/q-1)/du[j]*mp[i][j];
            }
        }
    }
    gauss();
    for(int i=1;i<=n;i++){
        printf("%.9lf\n",(double)x[i]);
    }
    //while(1);
}

BZOJ 1013 [JSOI2008]球形空间产生器sphere 高斯消元

Mon, 19 Jun 2017 16:28:40 GMT

Description

有一个球形空间产生器能够在n维空间中产生一个坚硬的球体。现在，你被困在了这个n维球体中，你只知道球面上n+1个点的坐标，你需要以最快的速度确定这个n维球体的球心坐标，以便于摧毁这个球形空间产生器。

Input

第一行是一个整数n(1<=N=10)。接下来的n+1行，每行有n个实数，表示球面上一点的n维坐标。每一个实数精确到小数点后6位，且其绝对值都不超过20000。

Output

有且只有一行，依次给出球心的n维坐标（n个实数），两个实数之间用一个空格隔开。每个实数精确到小数点后3位。数据保证有解。你的答案必须和标准输出一模一样才能够得分。

Sample Input

2
0.0 0.0
-1.0 1.0
1.0 0.0

Sample Output

0.500 1.500

题解

直接列方程到每个点距离相等
手动化简一下就出来了

BZOJ 竟然不能多输出一个空格（气）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
double c[20],a[15][15],b[15],x[15],d;
int n;
void gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++)
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        if(im!=k){
            for(int i=k;i<=n;i++)
                swap(a[num][i],a[im][i]);
            swap(b[num],b[im]);
        }
        if(!a[num][k]){num--;continue;}
        for(int i=num+1;i<=n;i++){
            if(!a[num][k])continue;
            double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++){
                a[i][j]-=t*a[k][j];
            }
            b[i]-=t*b[k];
        }
    }
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--)
            b[i]-=a[i][j]*x[j];
        x[i]=b[i]/a[i][i];
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lf",&c[i]);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%lf",&d);
            a[i][j]=d-c[j];
            b[i]+=d*d-c[j]*c[j];
        }
        b[i]/=2;
    }
    gauss();
    for(int i=1;i<n;i++){
        printf("%.3lf ",x[i]);
    }
    printf("%.3lf",x[n]);
}

[SDOI2007] 线性方程组高斯消元模板

Mon, 19 Jun 2017 16:06:31 GMT

【问题描述】

已知 n 元线性一次方程组。
$$ a_{1,1}x_1+a_{1,2}x_2+…+a_{1,n}x_n=b_1 $$
$$ a_{2,1}x_1+a_{2,2}x_2+…+a_{2,n}x_n=b_2 $$
$$…………$$ $$ a_{n,1}x_1+a_{n,2}x_2+…+a_{n,n}x_n=b_n $$
其中： n<=50．系数是整数，绝对值<=100 , bi的值都是正整数且<300。编程任务：根据输入的数据，编程输出方程组的解的情况。

【输入】

第一行，未知数的个数。以下n行n+1列：分别表示每一格方程的系数及方程右边的值。 $$ n $$ $$ a_{1,1} a_{1,2} … a_{1,n} b_1 $$ $$ a_{2,1} a_{2,2} … a_{2,n} b_2 $$ $$…………$$ $$ a_{n,1} a_{n,2} … a_{n,n} b_n $$

【输出】

如果方程组无实数解输出−1
如果有无穷多实数解，输出 0
如果有唯一解,则输出解（小数点后保留两位小数，如果解是0,则不保留小数）

【样例输入】

3
2 -1 1 1
4 1 -1 5
1 1 1 0

【样例输出】

x1=1.00
x2=0
x3=-1.00

题解

高斯消元板子

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int n;
double a[200][200],b[200],x[200];
int gauss(){
    int im,num=1;
    for(int k=1;k<=n;k++,num++){
        im=k;
        for(int i=k+1;i<=n;i++){
            if(fabs(a[i][k])>fabs(a[im][k]))
                im=i;
        }
        if(im!=k){
            for(int i=k;i<=n;i++)
                swap(a[num][i],a[im][i]);
            swap(b[num],b[im]);
        }
        if(!a[num][k]) {num--;continue;}
        for(int i=num+1;i<=n;i++){
            if(!a[num][k]) continue;
            double t=a[i][k]/a[num][k];
            for(int j=k;j<=n+1;j++)
                a[i][j]-=t*a[k][j];
            b[i]-=t*b[k];
        }
    }
    for(int i=num;i<=n;i++)
        if(!a[i][n]&&b[i])
            return -1;
    for(int i=n;i>=1;i--){
        for(int j=n;j>=i+1;j--)
            b[i]-=a[i][j]*x[j];
        if(!a[i][i]&&b[i]!=0)
            return -1;
        if(!a[i][i]&&!b[i])
            return 0;
        x[i]=b[i]/a[i][i];
    }
    return 1;
}
int main()
{
    //freopen("gaess.in","r",stdin);
    //freopen("gaess.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%lf",&a[i][j]);
        }
        scanf("%lf",&b[i]);
    }
    int s=gauss();
    if(s!=1)
        printf("%d",s);
    else {
        for(int i=1;i<=n;i++){
            if(x[i]==0)
                printf("x%d=0\n",i);
            else{
                printf("x%d=%.2lf\n",i,x[i]);
            }
        }
    }
    //while(1);
}

BZOJ 2097 [Usaco2010 Dec]Exercise 奶牛健美操题解二分答案树贪心 dfs

Sun, 18 Jun 2017 17:14:36 GMT

Description

Farmer John为了保持奶牛们的健康，让可怜的奶牛们不停在牧场之间的小路上奔跑。这些奶牛的路径集合可以被表示成一个点集和一些连接两个顶点的双向路，使得每对点之间恰好有一条简单路径。简单的说来，这些点的布局就是一棵树，且每条边等长，都为1。对于给定的一个奶牛路径集合，精明的奶牛们会计算出任意点对路径的最大值，我们称之为这个路径集合的直径。如果直径太大，奶牛们就会拒绝锻炼。 Farmer John把每个点标记为1..V (2 <= V <= 100,000)。为了获得更加短的直径，他可以选择封锁一些已经存在的道路，这样就可以得到更多的路径集合，从而减小一些路径集合的直径。我们从一棵树开始，FJ可以选择封锁S (1 <= S <= V-1)条双向路，从而获得 S+1个路径集合。你要做的是计算出最佳的封锁方案，使得他得到的所有路径集合直径的最大值尽可能小。 Farmer John告诉你所有V-1条双向道路，每条表述为：顶点A_i (1 <= A_i <= V) 和 B_i (1 <= B_i <= V; A_i!= B_i)连接。我们来看看如下的例子：线性的路径集合(7个顶点的树) 1---2---3---4---5---6---7 如果FJ可以封锁两条道路，他可能的选择如下： 1---2 | 3---4 | 5---6---7 这样最长的直径是2，即是最优答案(当然不是唯一的)。

Input

第1行：两个空格分隔的整数V和S * 第2...V行：两个空格分隔的整数A_i和B_i

Output

第1行：一个整数，表示FJ可以获得的最大的直径。

Sample Input

7 2
6 7
3 4
6 5
1 2
3 2
4 5

Sample Output

2

题解

二分答案贪心验证
每次dfs时将子节点到他的dis记录一直删边直到小于mid

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int son[100005],mid;
struct edge{
    int END,next;
}v[200005];
int first[100005],p,f[100005],q[100005],tot;
void add(int a,int b){
    v[p].END=b;v[p].next=first[a];first[a]=p++;
    v[p].END=a;v[p].next=first[b];first[b]=p++;
}
int cmp(const int a,const int b){
    return b<a;
}
void dfs(int rt,int fa){
    f[rt]=0;
    for(int i=first[rt];i!=-1;i=v[i].next)
        if(v[i].END!=fa) dfs(v[i].END,rt);
    int cnt=0;q[0]=0;
    for(int i=first[rt];i!=-1;i=v[i].next)
        if(v[i].END!=fa) q[++cnt]=f[v[i].END]+1;
    sort(q+1,q+cnt+1,cmp);
    if(!cnt) return;
    if(cnt==1){
        if(q[1]>mid){
            tot++;
            return;
        }
        else {f[rt]=q[1];return;}
    }
    int i=2;
    while(q[i-1]+q[i]>mid&&i<=cnt){
        tot++;
        i++;
    }
    if(i==cnt+1&&q[i-1]>mid)tot++;
    f[rt]=q[i-1];
}
int main()
{
    memset(first,-1,sizeof(first));
    int n,m;
    scanf("%d%d",&n,&m);
    int a,b;
    for(int i=1;i<n;i++){
        scanf("%d%d",&a,&b);
        add(a,b);
    }
    //int ans=0;
    int l=1,r=n;
    while(l<r){
        mid=l+r>>1;tot=0;
        dfs(1,0);
        if(tot<=m)r=mid;
        else l=mid+1;
    }
    printf("%d",l);
    //while(1);
}

BZOJ 3507 [Cqoi2014]通配符匹配 hash 题解

Sun, 18 Jun 2017 16:21:32 GMT

Description

几乎所有操作系统的命令行界面(CLI)中都支持文件名的通配符匹配以方便用户。最常见的通配符有两个，一个是星号(“”’)，可以匹配0个及以上的任意字符：另一个是问号(“？”)，可以匹配恰好一个任意字符。现在需要你编写一个程序，对于给定的文件名列表和一个包含通配符的字符串，判断哪些文件可以被匹配。

Input

第一行是一个由小写字母和上述通配符组成的字符串。
第二行包含一个整数n，表示文件个数。
接下来n行，每行为一个仅包含小写字母字符串，表示文件名列表。

Output

输出n行，每行为“YES”或“NO”，表示对应文件能否被通配符匹配。

Sample Input

*aca?ctc
6
acaacatctc
acatctc
aacacatctc
aggggcaacacctc
aggggcaacatctc
aggggcaacctct

Sample Output

YES
YES
YES
YES
YES
NO

题解

将原字符串由'*'分成若干段
记录每一个'?'的位置
分段hash 将文件首尾先匹配然后在中间贪心的匹配

/*
 * @Author: WildRage 
 * @Date: 2017-06-17 10:45:09 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-06-17 11:09:39
 */
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<stack>
using namespace std;
#define ULL unsigned long long
const ULL base=31; 
ULL pw[100005],f[15][15],HASH[100005];
int pos[15],cnt,num[15],s[15][15],n,lenth;
char S[100005],a[100005];
ULL get_hash(int l,int r){
    return HASH[r]-HASH[l-1]*pw[r-l+1];
}
bool OK(int i,int k){
    for(int j=0;j<=num[k];j++){
        if(s[k][j]==0){i++;continue;}
        if(f[k][j]!=get_hash(i,i+s[k][j]-1))return 0;
        i+=s[k][j]+1;
    }
    return 1;
}
bool work(char *b){
    int len=strlen(b+1);
    if(!cnt){
        if(lenth!=len)return 0;
        for(int i=1;i<=lenth;i++)
            if(S[i]!=b[i]&&S[i]!='?')return 0;
        return 1;
    }
    if(len<(pos[1]-1)+(lenth-pos[cnt]))return 0;
    for(int i=1;i<pos[1];i++)if(S[i]!=b[i]&&S[i]!='?')return 0;
    for(int i=lenth,j=len;i>pos[cnt];i--,j--)
        if(S[i]!=b[j]&&S[i]!='?')return 0;
    for(int i=1;i<=len;i++) HASH[i]=HASH[i-1]*base+b[i];
    int MAX=len-(lenth-pos[cnt])+1;
    int i=pos[1];
    for(int k=2;k<=cnt;k++){
        while(i<=MAX){
            if(OK(i,k))break;
            i++;
        }
        i+=pos[k]-pos[k-1]-1;
        if(i>MAX) return 0;
    }
    return 1;
}
int main()
{
    //freopen("match.in","r",stdin);
    //freopen("match.out","w",stdout);
    scanf("%s",S+1);
    lenth=strlen(S+1);
    pw[0]=1;
    cnt=0;
    for(int i=1;i<=100000;i++)pw[i]=pw[i-1]*base;
    for(int i=1;i<=lenth;i++)
        if(S[i]=='*') 
            pos[++cnt]=i;
    for(int i=2;i<=cnt;i++){
        num[i]=0;
        for(int j=pos[i-1]+1;j<pos[i];j++){
            if(S[j]=='?'){
                num[i]++;
                continue;
            }
            s[i][num[i]]++;
            f[i][num[i]]=f[i][num[i]]*base+S[j];
        }
    }
    scanf("%d",&n);
    while(n--){
        scanf("%s",a+1);
        if(work(a))puts("YES");
        else puts("NO");
    }
    //while(1);
}

BZOJ 4027 [HEOI2015]兔子与樱花贪心 dfs

Sat, 17 Jun 2017 10:10:22 GMT

Description

很久很久之前，森林里住着一群兔子。有一天，兔子们突然决定要去看樱花。兔子们所在森林里的樱花树很特殊。樱花树由n个树枝分叉点组成，编号从0到n-1，这n个分叉点由n-1个树枝连接，我们可以把它看成一个有根树结构，其中0号节点是根节点。这个树的每个节点上都会有一些樱花，其中第i个节点有c_i朵樱花。樱花树的每一个节点都有最大的载重m，对于每一个节点i，它的儿子节点的个数和i节点上樱花个数之和不能超过m，即son(i) + c_i <= m，其中son(i)表示i的儿子的个数，如果i为叶子节点，则son(i) = 0 现在兔子们觉得樱花树上节点太多，希望去掉一些节点。当一个节点被去掉之后，这个节点上的樱花和它的儿子节点都被连到删掉节点的父节点上。如果父节点也被删除，那么就会继续向上连接，直到第一个没有被删除的节点为止。  现在兔子们希望计算在不违背最大载重的情况下，最多能删除多少节点。注意根节点不能被删除，被删除的节点不被计入载重。

Input

第一行输入两个正整数，n和m分别表示节点个数和最大载重第二行n个整数c_i，表示第i个节点上的樱花个数接下来n行，每行第一个数k_i表示这个节点的儿子个数，接下来k_i个整数表示这个节点儿子的编号

Output

一行一个整数，表示最多能删除多少节点。

Sample Input

10 4
0 2 2 2 4 1 0 4 1 1
3 6 2 3
1 9
1 8
1 1
0
0
2 7 4
0
1 5
0

Sample Output

1

题解

跑一遍dfs由下到上贪心就好
选最小的

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> ch[2000005];
struct Tree{
    int v;
}tree[2000005];
int m,ans;
int cmp(const int a,const int b){
    return tree[a].v<tree[b].v;
}
void dfs(int rt){
    for(int i=0;i<ch[rt].size();i++) dfs(ch[rt][i]);
    sort(ch[rt].begin(),ch[rt].end(),cmp);
    int i;
    for(i=0;i<ch[rt].size();i++){
        if(tree[rt].v+tree[ch[rt][i]].v-1<=m){
            tree[rt].v+=tree[ch[rt][i]].v-1;
            ans++;            
        }
        else break;        
    }
}
int main()
{
    //freopen("sakura.in","r",stdin);
    //freopen("sakura.out","w",stdout);
    int n,t,s;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)scanf("%d",&tree[i].v);
    for(int i=0;i<n;i++){
        scanf("%d",&t);
        tree[i].v+=t;
        while(t--){
            scanf("%d",&s);
            ch[i].push_back(s);
        }
    }
    dfs(0);
    printf("%d\n",ans);
    //while(1);
}

BZOJ 4873 [Shoi2017]寿司餐厅网络流

Wed, 14 Jun 2017 16:18:56 GMT

Description

Kiana最近喜欢到一家非常美味的寿司餐厅用餐。每天晚上，这家餐厅都会按顺序提供n种寿司，第i种寿司有一个代号ai和美味度di,i，不同种类的寿司有可能使用相同的代号。每种寿司的份数都是无限的，Kiana也可以无限次取寿司来吃，但每种寿司每次只能取一份，且每次取走的寿司必须是按餐厅提供寿司的顺序连续的一段，即Kiana 可以一次取走第1,2种寿司各一份，也可以一次取走第2,3种寿司各一份，但不可以一次取走第1,3种寿司。由于餐厅提供的寿司种类繁多，而不同种类的寿司之间相互会有影响：三文鱼寿司和鱿鱼寿司一起吃或许会很棒，但和水  果寿司一起吃就可能会肚子痛。因此，Kiana定义了一个综合美味度d(i,j)(i<j)，表示在一次取的寿司中，如果包含了餐厅提供的从第i份到第j份的所有寿司，吃掉这次取的所有寿司后将获得的额外美味度。由于取寿司需要花费一些时间，所以我们认为分两次取来的寿司之间相互不会影响。注意在吃一次取的寿司时，不止一个综合美味度会被累加，比如若Kiana一次取走了第1,2,3种寿司各一份，除了d(1,3)以外，d(1,2),d(2,3)也会被累加进总美味度中。神奇的是，Kiana的美食评判标准是有记忆性的，无论是单种寿司的美味度，还是多种寿司组合起来的综合美味度，在计入Kiana的总美味度时都只会被累加一次。比如，若Kiana某一次取走了第1,2种寿司各一份，另一次取走了第2,3 种寿司各一份，那么这两次取寿司的总美味度为d(1,1)+d(2,2)+d(3,3)+d(1,2)+d(2,3)，其中d(2,2)只会计算一次。奇怪的是，这家寿司餐厅的收费标准很不同寻常。具体来说，如果Kiana一共吃过了c(c>0)种代号为x的寿司，则她需要为这些寿司付出mx^2+cx元钱，其中m是餐厅给出的一个常数。现在Kiana想知道，在这家餐厅吃寿司，自己能获得的总美味度（包括所有吃掉的单种寿司的美味度和所有被累加的综合美味度）减去花费的总钱数的最大值是多少。由于她不会算，所以希望由你告诉她

Input

第一行包含两个正整数n,m，分别表示这家餐厅提供的寿司总数和计算寿司价格中使用的常数。第二行包含n个正整数，其中第k个数ak表示第k份寿司的代号。接下来n行，第i行包含n-i+1个整数，其中第j个数d(i,i+j-1)表示吃掉寿司能获得的相应的美味度，具体含义见问题描述。 N<=100,Ai<=1000

Output

输出共一行包含一个正整数，表示Kiana能获得的总美味度减去花费的总钱数的最大值。

Sample Input

3 1
2 3 2
5 -10 15
-10 15
15

Sample Output

12

题解

将区间看做点每个[i,j]区间只要向[i+1,j],[i,j-1]连边
转换为最大权闭合子图
现在最麻烦的是解决每个点的权值
将单个的点即[i,j] (i==j)每个点的美味度减去它的代号(解决cm)向 Idx[a[i]]连边 Idx[]用来限制第一次吃的额外的花费

剩下的就和标准的最大权闭合子图一样了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
using namespace std;
const int INF=0x7fffffff;
int idIndex;
int read(){
    int res=0;
    static char ch;int flag=1;
	while((ch=getchar())<'0'||ch>'9')if(ch=='-')flag=-1;res=ch-48;
	while((ch=getchar())>='0'&&ch<='9')res=(res<<1)+(res<<3)+ch-48;
    return res*flag;
}
struct edge{
    int END,next,cap;
}v[1000005];
int first[10005],p;
void add(int a,int b,int c){
    v[p].END=b;v[p].next=first[a];v[p].cap=c;first[a]=p++;
    v[p].END=a;v[p].next=first[b];v[p].cap=0;first[b]=p++;
}
int a[150];
int Idx[1005],id[150][150];
int dis[10005],cur[10005];
bool vis[10005];
bool BFS(int S,int E){
    memset(dis,-1,sizeof(dis));
    memset(vis,0,sizeof(vis));
    vis[S]=1;dis[S]=0;
    queue<int> Q;
    Q.push(S);
    while(!Q.empty()){
        int u=Q.front();Q.pop();
        for(int i=first[u];i!=-1;i=v[i].next){
            if(!vis[v[i].END]&&v[i].cap>0){
                vis[v[i].END]=1;
                dis[v[i].END]=dis[u]+1;
                if(v[i].END==E)return 1;
                Q.push(v[i].END);
            }
        }
    }
    return 0;
}
int DFS(int S,int E,int a){
    if(S==E||a==0)return a;
    int flow=0,f;
    for(int &i=cur[S];i!=-1;i=v[i].next){
        if(dis[v[i].END]==dis[S]+1&&(f=DFS(v[i].END,E,min(a,v[i].cap)))>0){
            v[i].cap-=f;
            v[i^1].cap+=f;
            a-=f;
            flow+=f;
            if(f==0)break;
        }
    }
    //
    if(!flow) dis[S]=-1;
    return flow; 
}
int Dinic(int S,int E){
    int ans=0;
    while(BFS(S,E)){
        memcpy(cur,first,sizeof(first));
        ans+=DFS(S,E,INF);
    }
    return ans;
}
int main()
{
    int n,m;
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    int S=++idIndex,T=++idIndex;
    int maxn=0;
    for(int i=1;i<=n;i++) maxn=max(maxn,a[i]=read());
    for(int i=1;i<=maxn;i++){
        Idx[i]=++idIndex;
        add(Idx[i],T,m*i*i);
    }
    for(int i=1;i<=n;i++)for(int j=i;j<=n;j++)id[i][j]=++idIndex;
    int x;
    int ans=0;
    for(int i=1;i<=n;i++){
        for(int j=i;j<=n;j++){
            x=read();
            if(i==j)x-=a[i],add(id[i][j],Idx[a[i]],INF);
            else {
                if(id[i+1][j])add(id[i][j],id[i+1][j],INF);
                if(id[i][j-1])add(id[i][j],id[i][j-1],INF);
            }
            if(x>0) ans+=x,add(S,id[i][j],x);
            else add(id[i][j],T,-x);
        }
    }
    ans-=Dinic(S,T);
    printf("%d\n",ans);
    getchar();
    getchar();
    return 0;
}

BZOJ 1901 Dynamic Rankings 线段树套Treap

Wed, 14 Jun 2017 16:18:56 GMT

Description

给定一个含有n个数的序列a[1],a[2],a[3]……a[n]，程序必须回答这样的询问：对于给定的i,j,k，在a[i],a[i+1],a[i+2]……a[j]中第k小的数是多少(1≤k≤j-i+1)，并且，你可以改变一些a[i]的值，改变后，程序还能针对改变后的a继续回答上面的问题。你需要编一个这样的程序，从输入文件中读入序列a，然后读入一系列的指令，包括询问指令和修改指令。对于每一个询问指令，你必须输出正确的回答。第一行有两个正整数n(1≤n≤10000)，m(1≤m≤10000)。分别表示序列的长度和指令的个数。第二行有n个数，表示a[1],a[2]……a[n]，这些数都小于10^9。接下来的m行描述每条指令，每行的格式是下面两种格式中的一种。 Q i j k 或者 C i t Q i j k （i,j,k是数字，1≤i≤j≤n, 1≤k≤j-i+1）表示询问指令，询问a[i]，a[i+1]……a[j]中第k小的数。C i t (1≤i≤n，0≤t≤10^9)表示把a[i]改变成为t。

Input

对于每一次询问，你都需要输出他的答案，每一个输出占单独的一行。

Sample Input

5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6

题解

区间k大+修改
直接树套树

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[10005],n;
class Treap{
    class Node{
    public:
        int size,v,key;
        Node *ch[2];
        Node(int x){
            key=rand();v=x;size=1;
            ch[0]=ch[1]=NULL;
        }
        #define size(_) ((_)?(_)->size:0)
        void Pushup(){
            size=size(ch[0])+size(ch[1])+1;
        }
    }*root;
    Node *Merge(Node *A,Node *B){
        if(!A)return B;
        if(!B)return A;
        if(A->key>B->key){
            A->ch[1]=Merge(A->ch[1],B);
            A->Pushup();
            return A;
        }
        else {
            B->ch[0]=Merge(A,B->ch[0]);
            B->Pushup();
            return B;
        }
    }
    typedef pair<Node*,Node*> DNode;
    DNode Split(Node *rt,int k){
        if(!rt)return DNode(NULL,NULL);
        DNode o;
        if(size(rt->ch[0])>=k){
            o=Split(rt->ch[0],k);
            rt->ch[0]=o.second;
            rt->Pushup();
            o.second=rt;
        }
        else{
            o=Split(rt->ch[1],k-size(rt->ch[0])-1);
            rt->ch[1]=o.first;
            rt->Pushup();
            o.first=rt;
        }
        return o;
    }
public:
    Treap(){
        root=NULL;
    }
    int kth(int k){
        DNode x=Split(root,k-1);
        DNode y=Split(x.second,1);
        Node *ans=y.first;
        root=Merge(x.first,Merge(y.first,y.second));
        return ans->v;
    }
    int rank(int x){
        return rank(root,x);
    }
    int rank(Node *rt,int x){
        if(!rt)return 0;
        return x<=rt->v?rank(rt->ch[0],x):rank(rt->ch[1],x)+size(rt->ch[0])+1;
    }
    void Insert(int x){
        int k=rank(root,x);
        DNode y=Split(root,k);
        Node *n=new Node(x);
        root=Merge(Merge(y.first,n),y.second);
    }
    void remove(int x){
        int k=rank(root,x);
        DNode a=Split(root,k);
        DNode b=Split(a.second,1);
        root=Merge(a.first,b.second);
    }
}root[40000];
#define lch l,m,rt<<1
#define rch m+1,r,rt<<1|1 

void build(int l,int r,int rt){
    for(int i=l;i<=r;i++) root[rt].Insert(a[i]);
}
void buildtree(int l,int r,int rt){
    build(l,r,rt);
    if(l==r)return;
    int m=l+r>>1;
    buildtree(lch);
    buildtree(rch);
}
void updata(int k,int x,int y,int l,int r,int rt){
    root[rt].remove(y);
    root[rt].Insert(x);
    if(l==r)return;
    int m=l+r>>1;
    if(k<=m) updata(k,x,y,lch);
    else updata(k,x,y,rch);
}
int rank(int L,int R,int x,int l,int r,int rt){
    if(L<=l&&R>=r)return root[rt].rank(x);
    int m=l+r>>1;
    if(R<=m)return rank(L,R,x,lch);
    if(L>m) return rank(L,R,x,rch);
    return rank(L,R,x,lch)+rank(L,R,x,rch);
}
int kth(int L,int R,int k){
    int l=-1e10,r=1e10;
    while(l<=r){
        int m=l+r>>1;
        int num=rank(L,R,m,1,n,1)+1;
        if(num<=k)l=m+1;
        else r=m-1;
    }
    return r;
}
int main()
{   
    int m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    buildtree(1,n,1);
    char s[5];int i,j,k,t;
    while(m--){
        scanf("%s",s);
        if(s[0]=='Q'){
            scanf("%d%d%d",&i,&j,&k);
            printf("%d\n",kth(i,j,k));
        }
        else{
            scanf("%d%d",&i,&t);
            updata(i,t,a[i],1,n,1);
            a[i]=t;
        }
    }
}

BZOJ 3172 [Tjoi2013]单词 fail tree

Wed, 14 Jun 2017 16:18:56 GMT

Description

某人读论文，一篇论文是由许多单词组成。但他发现一个单词会在论文中出现很多次，现在想知道每个单词分别在论文中出现多少次。

Input

第一个一个整数N,表示有多少个单词，接下来N行每行一个单词。每个单词由小写字母组成，N<=200,单词长度不超过10^6

Output

输出N个整数，第i行的数字表示第i个单词在文章中出现了多少次。

Sample Input

3
a
aa
aaa

Sample Output

6
3
1

题解

fail 树照着打个板子

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
char S[1000005];
int Index;
struct Trie{
    Trie *ch[26];
    Trie *fail;
    int id,num;
    Trie(){memset(ch,0,sizeof(ch));fail=NULL;fail=0;num=0;id=++Index;}
}*root,*word[220];
void insert(char *s,int x){
    int len=strlen(s);
    Trie *now=root;
    for(int i=0;i<len;i++){
        if(!now->ch[s[i]-'a'])now->ch[s[i]-'a']=new Trie();
        now=now->ch[s[i]-'a'];
        now->num++;
    }
    word[x]=now;
}
struct edge{
    Trie *END;edge *next;
}*first[26000500];
void add(Trie *a,Trie *b){
    edge *k=new edge;
    k->END=b;
    k->next=first[a->id];
    first[a->id]=k;
}
void get_fail(){
    queue<Trie*> Q;
    Trie *now=root,*temp;
    Q.push(now);
    while(!Q.empty()){
        temp=Q.front();Q.pop();
        for(int i=0;i<26;i++){
            if(temp->ch[i]){
                if(temp==root){
                    temp->ch[i]->fail=root;
                    add(root,temp->ch[i]);
                }
                else{
                    now=temp->fail;
                    while(now&&now->ch[i]==NULL) now=now->fail;
                    if(now==NULL)add(root,temp->ch[i]),temp->ch[i]->fail=root;
                    else add(now->ch[i],temp->ch[i]),temp->ch[i]->fail=now->ch[i];
                }
                Q.push(temp->ch[i]);
            }
        }
    }
}
void dfs(Trie *rt){
    for(edge *now=first[rt->id];now;now=now->next){
        dfs(now->END);
        rt->num+=now->END->num;
    }
}
int main()
{
    int n;
    root=new Trie();
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",S);
        insert(S,i);
    }
    get_fail();
    dfs(root);
    for(int i=1;i<=n;i++){
        printf("%d\n",word[i]->num);
    }
}

BZOJ 4318 OSU! 概率DP

Wed, 14 Jun 2017 08:22:14 GMT

Description

osu 是一款群众喜闻乐见的休闲软件。我们可以把osu的规则简化与改编成以下的样子: 一共有n次操作，每次操作只有成功与失败之分，成功对应1，失败对应0，n次操作对应为1个长度为n的01串。在这个串中连续的 X个1可以贡献X^3 的分数，这x个1不能被其他连续的1所包含（也就是极长的一串1，具体见样例解释）现在给出n，以及每个操作的成功率，请你输出期望分数，输出四舍五入后保留1位小数。

Input

第一行有一个正整数n,表示操作个数。接下去n行每行有一个[0,1]之间的实数，表示每个操作的成功率。

Output

只有一个实数，表示答案。答案四舍五入后保留1位小数。

Sample Input

3
0.5
0.5
0.5

Sample Output

6.0

【样例说明】

000分数为0，001分数为1，010分数为1，100分数为1，101分数为2，110分数为8，011分数为8，111分数为27，总和为48，期望为48/8=6.0
N<=100000

题解

考虑前面以确定，第i位如果为1则贡献为 $$(x+1)^3-x^3=3x^2+3x+1$$
维护$$x^2,x$$就可以了

#include<cstdio>
#include<cstring>
using namespace std;
double x[100005],x2[100005],f[100005];
int main()
{
    int n;
    double a;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lf",&a);
        x[i]=(x[i-1]+1)*a;
        x2[i]=(x2[i-1]+2*x[i-1]+1)*a;
        f[i]=f[i-1]+(3*x2[i-1]+3*x[i-1]+1)*a;
    }
    printf("%.1f",f[n]);
}

BZOJ 1426 收集邮票

Wed, 14 Jun 2017 08:22:14 GMT

Description

有n种不同的邮票，皮皮想收集所有种类的邮票。唯一的收集方法是到同学凡凡那里购买，每次只能买一张，并且买到的邮票究竟是n种邮票中的哪一种是等概率的，概率均为1/n。但是由于凡凡也很喜欢邮票，所以皮皮购买第k张邮票需要支付k元钱。现在皮皮手中没有邮票，皮皮想知道自己得到所有种类的邮票需要花费的钱数目的期望。

Input

一行,一个数字N N<=10000

Output

要付出多少钱. 保留二位小数

Sample Input

3

Sample Output

21.25

题解

首先考虑每张邮票1元钱，f[i]为当前有i张邮票，要集齐n种邮票的期望花费. $$f[i]=i/nf[i]+(n-i)/nf[i+1]+1$$当花费为k时 g[i]为当前有i张邮票,要集齐n种邮票的期望花费。
我们可以认为买的最后一张邮票的花费为1,倒数第k张的花费为k。这样 $$g[i]=i/n*(g[i]+f[i]+1)+(n-i)/n*(g[i+1]+f[i+1]+1)$$化简后就可以O(n)递推了.

/*
 * @Author: WildRage 
 * @Date: 2017-06-14 08:15:56 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-06-14 08:19:55
 */
#include<iostream>
#include<cstdio>
using namespace std;
double f[10005],g[10005];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=n-1;i>=0;i--)f[i]=f[i+1]+(double)n/(n-i);
    for(int i=n-1;i>=0;i--)g[i]=(double)i/(n-i)*f[i]+g[i+1]+f[i+1]+(double)n/(n-i);
    printf("%.2f",g[0]);
}

网络流24题太空飞行计划

Wed, 14 Jun 2017 07:10:14 GMT

【问题描述】

W 教授正在为国家航天中心计划一系列的太空飞行。每次太空飞行可进行一系列商业性实验而获取利润。现已确定了一个可供选择的实验集合E={E1,E2,…,Em}，和进行这些实验需要使用的全部仪器的集合I={ I1, I2,…,In }。实验Ej 需要用到的仪器是I的子集Rj∈I。配置仪器Ik 的费用为ck 美元。实验Ej 的赞助商已同意为该实验结果支付pj 美元。W教授的任务是找出一个有效算法，确定在一次太空飞行中要进行哪些实验并因此而配置哪些仪器才能使太空飞行的净收益最大。这里净收益是指进行实验所获得的全部收入与配置仪器的全部费用的差额。

【编程任务】

对于给定的实验和仪器配置情况，编程找出净收益最大的试验计划。

【数据输入】

第1行有2个正整数m和n(m,n <= 100)。m是实验数，n是仪器数。接下来的m行，每行是一个实验的有关数据。第一个数赞助商同意支付该实验的费用；接着是该实验需要用到的若干仪器的编号。最后一行的n个数是配置每个仪器的费用。

【结果输出】

第1行是实验编号；第2行是仪器编号；最后一行是净收益。

【输入文件示例】shuttle.in

2 3
10 1 2
25 2 3
5 6 7

【输出文件示例】shuttle.out

1 2
1 2 3
17

题解

最大权闭合子图很裸的题，复习一下板子

/*
 * @Author: WildRage 
 * @Date: 2017-06-13 21:23:24 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-06-13 21:48:22
 */
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int INF=0x7fffffff;
struct edge{
    int END,next,cap;
}v[100005];
int first[1005],p;
void add(int a,int b,int c){
    v[p].END=b;v[p].next=first[a];v[p].cap=c;first[a]=p++;
    v[p].END=a;v[p].next=first[b];v[p].cap=0;first[b]=p++;
}
int cur[1005],dis[1005];
bool vis[1005];
bool BFS(int S,int E){
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));
    queue<int> Q;
    Q.push(S);
    dis[S]=0;vis[S]=1;
    while(!Q.empty()){
        int u=Q.front();Q.pop();
        for(int i=first[u];i!=-1;i=v[i].next){
            if(!vis[v[i].END]&&v[i].cap>0){
                vis[v[i].END]=1;
                dis[v[i].END]=dis[u]+1;
                if(v[i].END==E)return 1;
                Q.push(v[i].END);
            }
        }
    }
    return 0;
}
int DFS(int S,int E,int a){
    if(S==E||a==0)return a;
    int flow=0,f;
    for(int i=first[S];i!=-1;i=v[i].next){
        if(dis[S]+1==dis[v[i].END]&&(f=DFS(v[i].END,E,min(a,v[i].cap)))>0){
            v[i].cap-=f;
            v[i^1].cap+=f;
            flow+=f;
            a-=f;
        }
    }
    if(!flow)dis[S]=-1;
    return flow;
}
int Dinic(int S,int E){
    int ans=0;
    while(BFS(S,E)){
        ans+=DFS(S,E,INF);
    }
    //printf("%d\n",ans);
    //while(1);
    return ans;
}
int Main()
{
    memset(first,-1,sizeof(first));
    int n,m;
    freopen("shuttle.in","r",stdin);
	freopen("shuttle.out","w",stdout);
    scanf("%d%d",&n,&m);
    int ans=0;
    char ch;
    for(int x,i=1;i<=n;i++){
        scanf("%d",&x);ans+=x;
        add(0,i,x);
        while(1){
            while((ch=getchar())==' ');
            ungetc(ch,stdin);
            if(ch=='\n'||ch=='\r')break;
            scanf("%d",&x);
            add(i,x+n,INF);
        }
    }
    for(int x,i=1;i<=m;i++){
        scanf("%d",&x);
        add(i+n,m+n+1,x);
    }
    ans=ans-Dinic(0,n+m+1);
    for(int i=1;i<=n;i++)
        if(dis[i]>=0)
            printf("%d ",i);
    puts("");
    for(int i=1;i<=m;i++)
        if(dis[i+n]>=0)
            printf("%d ",i);
    puts("");
    printf("%d\n",ans);
    return 0;
}
int Wild=Main();
int main(){;}

[COGS 2248] 情书 AC自动机模板

Tue, 13 Jun 2017 19:45:56 GMT

【题目描述】

John平静的生活最近有了波澜：他已经连续n天受到陌生人的情书了。小小的心中充满了憧憬，但是某些人觉得有乐子可以找，决定伪造情书。John总结出了那个陌生人写信的习惯，也就是某些关键的字符串。如果一封信中这若干个关键字符串都出现，他就认为这是那个陌生人写的，否则就是他同学的恶作剧。注意，John可能收到多封情书。

【输入格式】

第一行一个整数n，表示关键字符串的个数，n<=100。
接下来n行，每行为一个长度不超过100的字符串。最后是若干段文本，每段文本以 $ 结尾。
由于写情书的人太疯狂，每封情书最长可以达到1350000个字符，但情书的个数不超过10。

【输出格式】

对于每一段文本对应一行输出。
‘Yes’表示是陌生人的来信，‘No’表示不是。
请注意大小写。

【样例输入】

3
i
love
wzk
ilovewzk$
lovewzk$

【样例输出】

Yes
No

题解

AC自动机板子
感谢TS_Hugh , LadyLex

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
char text[1350005];
int n;
struct Trie{
    vector<int> Q;
    Trie *ch[26],*fail;
    Trie(){
        Q.clear();memset(ch,0,sizeof(ch));fail=NULL;
    }
    void* operator new(size_t size);
}*root,*C,*num,*Q[100005];
void* Trie::operator new(size_t size){
    if(C==num){
        C=new Trie[1<<15];
        num=C+(1<<15);
    }
    return C++;
}
void insert(char *s,int x){
    int len=strlen(s);
    Trie *now=root;
    for(int i=0;i<len;i++){
        if(now->ch[s[i]-'a']==NULL)now->ch[s[i]-'a']=new Trie();
        now=now->ch[s[i]-'a'];
    }
    now->Q.push_back(x);
}
void build()
{
    root->fail=NULL;
    Q[0]=root;
    for(int i=0,j=0;i<=j;i++){
        for(int l=0;l<26;l++){
            if(Q[i]->ch[l]){
                Trie *now=Q[i]->fail;
                while(now&&!now->ch[l])now=now->fail;
                Q[i]->ch[l]->fail=now?now->ch[l]:root;
                Q[++j]=Q[i]->ch[l];
            }
        }
    }
}
bool read(){
    char c;
    int head=0;
    if(cin>>c){
        while(c!='$'){
            if(c=='\n'||c==' '){c=getchar();continue;}
            text[head++]=c;c=getchar();
        }
        text[head++]='$';
        return 1;
    }
    return 0;
}
bool via[105];
void work(){
    memset(via,0,sizeof(via));
    Trie *now=root;
    for(int i=0;text[i]!='$';i++){
        while(now&&!now->ch[text[i]-'a'])now=now->fail;
        now=now?now->ch[text[i]-'a']:root;
        for(Trie *i=now;i;i=i->fail){
            if(!i->Q.empty()){
                int l=i->Q.size();
                for(int j=0;j<l;j++)via[i->Q[j]]=1;
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)if(via[i])ans++;
    if(ans==n)puts("Yes");
    else puts("No");
}
int main()
{
    freopen("lettera.in","r",stdin);
    freopen("lettera.out","w",stdout);
    root=new Trie();
    char s[1000];
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        insert(s,i);
    }
    build();
    while(read()) work();
}

[BZOJ 4523][Cqoi2016]路由表 Trie树单调栈

Tue, 13 Jun 2017 17:35:35 GMT

Description

路由表查找是路由器在转发IP报文时的重要环节。通常路由表中的表项由目的地址、掩码、下一跳（Next Hop）地址和其他辅助信息组成。例如：当路由器收到一个IP报文时，会将报文中的目的IP地址与路由表中的表项逐条进行比较，选择匹配且最明确的表项，将报文转发给该表项中指定的下一跳。  匹配的过程是将报文中的目的地址和表项中的目的地址分别转为二进制串，再查看表项中的掩码长度，若掩码长度为x，则将两个二进制串的前x位进行比较，如果相同则认为匹配。所谓最明确是指在有多个表项匹配时，总是掩码长度最大的表项。也可以理解为匹配的二进制位最多的项。 IP地址转为二进制串的操作是把地址中4个整数（一定在y到255的范围内）分别转为8位二进制数，再顺序拼接起来，得到一个32位的二进制串。例如，192.168.1.253转为二进制串后为 11000000 10101000 00000001 11111101 我们以报文的目的地址为8.8.8.8为例，说明其在上述路由表的匹配过程。上表将地址均转为二进制串，并用红色标记出待比较的位（由掩码长度决定）。将红色部分与报文中的目的地址比较，可知0.0.0.0/1、8.8.8.0/24、8.8.8.8、32均能够匹配。路由器从中选取掩码长度最长（/32）的表项8.8.8.8/32，将报文转发给其对应的下一跳地址192.168.1.253。在实际的核心路由器中，路由表通常较大（现在互联网的全局路由表已经接60万条记录），并且会随着新接入设备不断扩张。为了分析路由表变化对转发产生的影响，网络工程师想要知道一段时间内某个IP地址的路由表项选择发生了多少次变化（变化是指由于最明确匹配等因素选择了不同的表项，不考虑下一跳地址）。

Input

第一行为整数M，表示共有M次操作。接下来M行，每行描述一次操作。操作有两种：
A D/L
其中.为一个IP地址，G为整数（1≤L≤32）。添加一条表项至路由表，其目的地址为 D掩码长度为L。下一跳地址由于没有用到，故省略。
Q D a b
其中D为一个IP地址，a,b为正整数（a≤b）。查询从第a次至第b次添加表项期间（含a、b），
目的地址D的路由表项选择发生了多少次变化。保证查询时表中至少有b个表项。
N<=10^6数据保证不会重复添加目的地址和掩码长度都相同的表项。

Output

包含若干行，每行仅有一个整数，依次对应每个查询操作。

题面

题解

以要查询的IP建一颗Trie树在终止节点打一个时间标记
每次查询用单调栈维护

/*
 * @Author: WildRage 
 * @Date: 2017-06-13 17:54:04 
 * @Last Modified by:   WildRage 
 * @Last Modified time: 2017-06-13 17:54:04 
 */
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
struct Trie{
    int T;
    Trie *ch[2];
    void *operator new (size_t size);
}*root,*num,*C;
void* Trie::operator new(size_t size){
    if(C==num){
        C=new Trie[1<<10];
        memset(C,0,sizeof(Trie)*(1<<10));
        num=C+(1<<10);
    }
    return C++;
}
int Index=0,cnt;
void insert(char *s){
    Trie *now=root;
    for(int i=0;i<cnt;i++){
        if(now->ch[s[i]-'0']==NULL)now->ch[s[i]-'0']=new Trie;
        now=now->ch[s[i]-'0'];
    }
    now->T=++Index;
}
int st[10005];
int query(char *s,int l,int r){
    int h=0;
    Trie *now=root;
    for(int i=0;i<cnt;i++){
        if(now->ch[s[i]-'0']==NULL)break;
        now=now->ch[s[i]-'0'];
        if(!now->T)continue;
        if(now->T>r)continue;
        if(now->T<l)while(h>=1)h--;
        if(now->T>=l&&now->T<=r){
            while(h>=1&&now->T<st[h])h--;
            st[++h]=now->T;
        }
    }
    return h;
}
int main()
{
    int m;
    scanf("%d",&m);
    char S[2],s[105];
    int a[5],b,l,r;
    root=new Trie;
    for(int i=1;i<=m;i++){
        scanf("%s",S);
        if(S[0]=='A'){
            cnt=0;
            scanf("%d.%d.%d.%d/%d",&a[1],&a[2],&a[3],&a[4],&b);
            for(int i=1;i<=4;i++){
                for(int j=7;j>=0;j--){
                    if(cnt+1>b)break;
                    if((a[i]>>j)&1)s[cnt]='1';
                    else s[cnt]='0';
                    cnt++;
                }
            }
            insert(s);
        }
        else{
            cnt=0;
            scanf("%d.%d.%d.%d %d %d",&a[1],&a[2],&a[3],&a[4],&l,&r);
            for(int i=1;i<=4;i++){
                for(int j=7;j>=0;j--){
                    if((a[i]>>j)&1)s[cnt]='1';
                    else s[cnt]='0';
                    cnt++;
                }
            }
            printf("%d\n",query(s,l,r));
        }
    }
}

[COGS 2051] 王者之剑题解网络流最大权闭合子图

Tue, 13 Jun 2017 15:35:35 GMT

【题目描述】

这是在阿尔托利亚·潘德拉贡成为英灵前的事情，她正要去拔出石中剑成为亚瑟王，在这之前她要去收集一些宝石。
宝石排列在一个n*m的网格中，每个网格中有一块价值为v(i,j)的宝石，阿尔托利亚·潘德拉贡可以选择自己的起点。
开始时刻为0秒。以下操作，每秒按顺序执行
1.在第i秒开始的时候，阿尔托利亚·潘德拉贡在方格（x,y）上，她可以拿走（x，y）中的宝石。
2.在偶数秒，阿尔托利亚·潘德拉贡周围四格的宝石会消失
3.若阿尔托利亚·潘德拉贡第i秒开始时在方格（x，y）上，则在第i+1秒可以立即移动到（x+1，y），（x，y+1），（x-1，y）或（x，y-1）上，也可以停留在（x,y)上。
求阿尔托利亚·潘德拉贡最多可以获得多少价值的宝石

【输入格式】

第一行给出数字N,M代表行列数.N,M均小于等于100，宝石的价值不会超过10000.下面N行M列用于描述数字矩阵

【输出格式】

输出最多可以拿到多少价值宝石

【样例输入】

2 2
1 2
2 1

【样例输出】

与网络流24题中方格取数相同
最大权闭合子图
黑白染色
相邻连INF的边
源点向白格子连格子权值的边
黑格子想汇点连权值的边

跑一遍最小割也就是最大流 Dinic解决

/*
 * @Author: WildRage 
 * @Date: 2017-06-13 16:37:09 
 * @Last Modified by:   WildRage 
 * @Last Modified time: 2017-06-13 16:37:09 
 */
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int INF=0x7fffffff;
struct edge{
    int END,cap,next;
}v[500000];
int first[10005],p;
void add(int a,int b,int c){
    v[p].END=b;v[p].next=first[a];v[p].cap=c;first[a]=p++;
    v[p].END=a;v[p].next=first[b];v[p].cap=0;first[b]=p++;
}
int dis[10005];
bool vis[10005];
bool BFS(int S,int E){
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));
    queue<int> Q;
    Q.push(S);
    dis[S]=0;vis[S]=1;
    while(!Q.empty()){
        int u=Q.front();Q.pop();
        for(int i=first[u];i!=-1;i=v[i].next){
            if(!vis[v[i].END]&&v[i].cap>0){
                vis[v[i].END]=1;
                dis[v[i].END]=dis[u]+1;
                if(v[i].END==E)return 1;
                Q.push(v[i].END);
            }
        }
    }
    return 0;
}
int DFS(int x,int a,int E){
    if(x==E||a==0)return a;
    int flow=0,f;
    for(int i=first[x];i!=-1;i=v[i].next){
        if(dis[x]+1==dis[v[i].END]&&(f=DFS(v[i].END,min(a,v[i].cap),E))>0){
            v[i].cap-=f;
            v[i^1].cap+=f;
            flow+=f;
            a-=f;
            if(a==0)break;
        }
    }
    if(!flow)dis[x]=-1;
    return flow;
}
int Dinic(int S,int E){
    int flow=0;
    while(BFS(S,E)){
        flow+=DFS(S,INF,E);
    }
    return flow;
}
int a[105][105];
template<class T>inline void read(T &res){
	static char ch;T flag=1;
	while((ch=getchar())<'0'||ch>'9')if(ch=='-')flag=-1;res=ch-48;
	while((ch=getchar())>='0'&&ch<='9')res=(res<<1)+(res<<3)+ch-48;res*=flag;
}
int Main(){
    freopen("Excalibur.in","r",stdin);
    freopen("Excalibur.out","w",stdout);
    memset(first,-1,sizeof(first));
    int m,n;
    int sum=0;
    read(m),read(n);
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++){
            read(a[i][j]);
            sum+=a[i][j];
    	}
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            if((i&1)^(j&1)){
                add(0,n*(i-1)+j,a[i][j]);
                if(j-1>=1)add(n*(i-1)+j,n*(i-1)+j-1,INF);
				if(i-1>=1)add(n*(i-1)+j,n*(i-2)+j,INF);
				if(i+1<=m)add(n*(i-1)+j,n*(i)+j,INF);
				if(j+1<=n)add(n*(i-1)+j,n*(i-1)+j+1,INF);
            }
            else{
                add(n*(i-1)+j,n*m+1,a[i][j]);
            }
            
        }
    }
    return printf("%d",sum-Dinic(0,m*n+1));
}
int A=Main();
int main(){;}

图库

Tue, 13 Jun 2017 15:30:32 GMT

[BZOJ 1954] The xor-longest Path Trie树贪心

Tue, 13 Jun 2017 14:30:32 GMT

Description

给定一棵n个点的带权树，求树上最长的异或和路径

Input

The input contains several test cases. The first line of each test case contains an integer n(1<=n<=100000), The following n-1 lines each contains three integers u(0 <= u < n),v(0 <= v < n),w(0 <= w < 2^31), which means there is an edge between node u and v of length w.

Output

For each test case output the xor-length of the xor-longest path.

Sample Input

Sample Output

题解

本题是要求树上的路径异或只要先预处理出每个点到根的路径的异或值又因为异或两次会抵消所以结果一定是对的

然后将所有点的异或值都插入一块Trie二进制由高到低

枚举每一个点贪心的在Trie树中找就可以了

/*
 * @Author: WildRage 
 * @Date: 2017-06-13 10:24:04 
 * @Last Modified by:   WildRage 
 * @Last Modified time: 2017-06-13 10:24:04 
 */
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct Trie_Node{
    Trie_Node *ch[27];
    Trie_Node(){
        memset(ch,0,sizeof(ch));
    }
}*root;
int ans;
inline void insert(char *s){
    int len=strlen(s);
    Trie_Node *now=root;
    for(int i=0;i<len;i++){
        if(now->ch[s[i]-'A']==NULL)
            now->ch[s[i]-'A']=new Trie_Node,ans++;
        now=now->ch[s[i]-'A'];
    }
}
int main()
{
    freopen("trie.in","r",stdin);
    freopen("trie.out","w",stdout);
    char s[105];
    root=new Trie_Node;ans++;
    while(scanf("%s",s)!=EOF) insert(s);
    printf("%d",ans);
}

[NOI2000] 单词查找树

Tue, 13 Jun 2017 14:20:10 GMT

[题目描述]

在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。为了提高查找和定位的速度，通常都要画出与单词列表所对应的单词查找树，其特点如下：

根节点不包含字母，除根节点外每一个节点都仅包含一个大写英文字母；
从根节点到某一节点，路径上经过的字母依次连起来所构成的字母序列，称为该节点对应的单词。单词列表中的每个词，都是该单词查找树某个节点所对应的单词；
在满足上述条件下，该单词查找树的节点数最少。

单词列表对应的单词查找树

A
AN  
ASP  
AS  
ASC  
ASCII  
BAS  
BASIC

对一个确定的单词列表，请统计对应的单词查找树的节点数（包括根节点）

[输入文件]

该文件为一个单词列表，每一行仅包含一个单词和一个换行/回车符。每个单词仅由大写的英文字符组成，长度不超过63个字符。文件总长度不超过32K，至少有一行数据。

[输出文件]

该文件中仅包含一个整数和一个换行/回车符。该整数为单词列表对应的单词查找树的节点数。

[输入输出文件样例]

Input

A
AN
ASP
AS
ASC
ASCII
BAS
BASIC

Output

题解

裸的Trie树
直接套板子

/*
 * @Author: WildRage 
 * @Date: 2017-06-13 10:24:04 
 * @Last Modified by:   WildRage 
 * @Last Modified time: 2017-06-13 10:24:04 
 */
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct Trie_Node{
    Trie_Node *ch[27];
    Trie_Node(){
        memset(ch,0,sizeof(ch));
    }
}*root;
int ans;
inline void insert(char *s){
    int len=strlen(s);
    Trie_Node *now=root;
    for(int i=0;i<len;i++){
        if(now->ch[s[i]-'A']==NULL)
            now->ch[s[i]-'A']=new Trie_Node,ans++;
        now=now->ch[s[i]-'A'];
    }
}
int main()
{
    freopen("trie.in","r",stdin);
    freopen("trie.out","w",stdout);
    char s[105];
    root=new Trie_Node;ans++;
    while(scanf("%s",s)!=EOF) insert(s);
    printf("%d",ans);
}

POJ 2406 Power Strings 题解 KMP 适配函数

Tue, 13 Jun 2017 13:50:32 GMT

Description

Given two strings a and b we define ab to be their concatenation. For example, if a = "abc" and b = "def" then ab = "abcdef" . If we think of concatenation as multiplication, exponentiation by a non-negative integer is defined in the normal way: a^0 = "" (the empty string) and a^(n+1) = a*(a^n) .

Input

Each test case is a line of input representing s, a string of printable characters. The length of s will be at least 1 and will not exceed 1 million characters. A line containing a period follows the last test case.

Output

For each s you should print the largest n such that $$s = a^n$$ for some string a.

Sample Input

abcd
aaaa
ababab
.

Sample Output

1
4
3

题解

主要考虑 KMP 中失陪函数的意义
因为整个串是会重复的
所以整个串的长度一定是串长减最后一个字符的fail的倍数

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1000005;
char S[N];
int next[N],len;
void get_next(){
    next[0]=-1;next[1]=0;
    for(int i=2,j=0;i<=len;i++){
        while(~j&&S[j+1]!=S[i])j=next[j];
        next[i]=++j;
    }
}
int main()
{
    while(1){
        memset(S,0,sizeof(S));
        scanf("%s",S);
        len=strlen(S)-1;
        if(S[0]=='.')break;
        get_next();
        //for(int i=1;i<=len;i++)printf("%d ",next[i]);
        //puts("");
        if((len+1)%(len-next[len])==0)printf("%d\n",(len+1)/(len-next[len]));
        else puts("1");
    }
}

[POJ3461] 乌力波 MP 题解板子

Tue, 13 Jun 2017 11:20:00 GMT

【题目描述】

法国作家乔治·佩雷克(Georges Perec，1936-1982)曾经写过一本书，《敏感字母》（La disparition），全篇没有一个字母‘e’。他是乌力波小组（Oulipo Group）的一员。下面是他书中的一段话：  Tout avait Pair normal, mais tout s’affirmait faux. Tout avait Fair normal, d’abord, puis surgissait l’inhumain, l’affolant. Il aurait voulu savoir où s’articulait l’association qui l’unissait au roman : stir son tapis, assaillant à tout instant son imagination, l’intuition d’un tabou, la vision d’un mal obscur, d’un quoi vacant, d’un non-dit : la vision, l’avision d’un oubli commandant tout, où s’abolissait la raison : tout avait l’air normal mais…

佩雷克很可能在下面的比赛中得到高分（当然，也有可能是低分）。在这个比赛中，人们被要求针对一个主题写出甚至是意味深长的文章，并且让一个给定的“单词”出现次数尽量少。我们的任务是给评委会编写一个程序来数单词出现了几次，用以得出参赛者最终的排名。参赛者经常会写一长串废话，例如500000个连续的‘T’。并且他们不用空格。因此我们想要尽快找到一个单词出现的频数，即一个给定的字符串在文章中出现了几次。更加正式地，给出字母表{‘A’,’B’,’C’,…,’Z’}和两个仅有字母表中字母组成的有限字符串：单词W和文章T，找到W在T中出现的次数。这里“出现”意味着W中所有的连续字符都必须对应T中的连续字符。T中出现的两个W可能会部分重叠。

【输入格式】

输入包含多组数据。输入文件的第一行有一个整数，代表数据组数。接下来是这些数据，以如下格式给出：第一行是单词W，一个由{‘A’,’B’,’C’,…,’Z’}中字母组成的字符串，保证1<=|W|<=10000（|W|代表字符串W的长度）第二行是文章T，一个由{‘A’,’B’,’C’,…,’Z’}中字母组成的字符串，保证|W|<=|T|<=1000000。

【输出格式】

对每组数据输出一行一个整数，即W在T中出现的次数。

【样例输入】

3
BAPC
BAPC
AZA
AZAZAZA
VERDI
AVERDXIVYERDIAN

【样例输出】

1
3
0

题解

就是MP板子

/*
 * @Author: WildRage 
 * @Date: 2017-06-12 17:26:02 
 * @Last Modified by: WildRage
 * @Last Modified time: 2017-06-12 19:01:45
 */
#include<cstdio>
#include<cstring>
using namespace std;
char S[1000005],T[1000005];
int next[1000005];
int len;
void get_next(char *a,int n){
    int j=0,k=-1;
    next[0]=-1;
    while(j<n){
        if(k==-1||T[j]==T[k]){
            next[++j]=++k;
        }
        else k=next[k];
    }
}
int main()
{
    freopen("oulipo.in","r",stdin);
    freopen("oulipo.out","w",stdout);
    int t;
    scanf("%d",&t);
    while(t--){
        int ans=0;
        scanf("%s",T);scanf("%s",S);
        int n=strlen(S);
        int m=strlen(T);
        get_next(T,m);
        int i=0,j=0;
        for(int i=0;i<n;i++){
            while(j>0&&S[i]!=T[j]) j=next[j];
            if(S[i]==T[j])j++;
            if(j==m)ans++,j=next[j];
        }
        printf("%d\n",ans);
    }
}

网络流笔记

Tue, 13 Jun 2017 09:41:05 GMT

网络流

是指在一个每条边都有容量（capacity）的有向图分配流，使一条边的流量不会超过它的容量。

最大流

Dinic

Dinic算法（又称Dinitz算法）是一个在网络流中计算最大流的强多项式复杂度的算法，设想由以色列（前苏联）的计算机科学家Yefim (Chaim) A. Dinitz在1970年提出。

最大流例题

[Usaco 2007 Open] Dining吃饭

题意：有N头牛，F种食物和D种饮料，每头牛有多种喜欢的食物和饮料，每头牛只可以吃一种食物和饮料，且每种食物和饮料都只能被一头牛吃掉。一头牛满意当且仅当它吃到满意的食物并且喝到想喝的饮料，问最多可能让多少头牛满意。

最小割

最大权闭合子图

现在有一个有向图，每个点有点权，点权可正可负。对于任意一条有向边i和j，选择了点i就必须选择点j，你需要选择一些点使得得到权值最大。

解题

将由源点S向权值为正的点连流量为i的边，将权值为负的点向汇点连边
限制关系连流量为INF的图

[NOI2006 最大获利]

建权值为Ci的一个图像Ai与Bi建图转化为最大权闭合子图

其他

二分图最大点权匹配
二分图最大点权独立集

费用流

最大费用流
最小费用最大流

连续最短路算法

贪心思想
从源点开始每次寻找总费用最小的增广路
直到不能增广为止

[SDOI2009]晨跑

Elaxia最近迷恋上了空手道，他为自己设定了一套健身计划，比如俯卧撑、仰卧起坐等等，不过到目前为止，他坚持下来的只有晨跑。现在给出一张学校附近的地图，这张地图中包含N个十字路口和M条街道，Elaxia只能从一个十字路口跑向另外一个十字路口，街道之间只在十字路口处相交。Elaxia每天从寝室出发跑到学校，保证寝室编号为1，学校编号为N。 Elaxia的晨跑计划是按周期（包含若干天）进行的，由于他不喜欢走重复的路线，所以在一个周期内，每天的晨跑路线都不会相交（在十字路口处），寝室和学校不算十字路口。Elaxia耐力不太好，他希望在一个周期内跑的路程尽量短，但是又希望训练周期包含的天数尽量长。除了练空手道，Elaxia其他时间都花在了学习和找MM上面，所有他想请你帮忙为他设计一套满足他要求的晨跑计划。

[SDOI2007]修车

同一时刻有N位车主带着他们的爱车来到了汽车维修中心。维修中心共有M位技术人员，不同的技术人员对不同的车进行维修所用的时间是不同的。现在需要安排这M位技术人员所维修的车及顺序，使得顾客平均等待的时间最小。说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

将每个人拆成n个点
第i个点代表这个人修的车中倒数第i辆
将每辆车向这些点连边，流量为1
的费用为f[i][j]*i
源点连向车，工作人员向汇点连边

[SDOI2016]数字匹配

有 n 种数字，第 i 种数字是 ai、有 bi 个，权值是 ci。若两个数字 ai、aj 满足，ai 是 aj 的倍数，且 ai/aj 是一个质数，那么这两个数字可以配对，并获得 ci×cj 的价值。一个数字只能参与一次配对，可以不参与配对。在获得的价值总和不小于 0 的前提下，求最多进行多少次配对。

以奇数和偶数因子建二分图

[SDOI2013]费用流

Alice和Bob在图论课程上学习了最大流和最小费用最大流的相关知识。
最大流问题：给定一张有向图表示运输网络，一个源点S和一个汇点T，每条边都有最大流量。
一个合法的网络流方案必须满足：
(1)每条边的实际流量都不超过其最大流量且非负；
(2)除了源点S和汇点T之外，对于其余所有点，都满足该点总流入流量等于该点总流出流量；而S点的净流出流量等于T点的净流入流量，这个值也即该网络流方案的总运输量。最大流问题就是对于给定的运输网络，求总运输量最大的网络流方案。
上图表示了一个最大流问题。
对于每条边，右边的数代表该边的最大流量，左边的数代表在最优解中，该边的实际流量。需要注意到，一个最大流问题的解可能不是唯一的。对于一张给定的运输网络，Alice先确定一个最大流，如果有多种解，Alice可以任选一种；之后Bob在每条边上分配单位花费（单位花费必须是非负实数），要求所有边的单位花费之和等于P。总费用等于每一条边的实际流量乘以该边的单位花费。需要注意到，Bob在分配单位花费之前，已经知道Alice所给出的最大流方案。现茌Alice希望总费用尽量小，而Bob希望总费用尽量大。我们想知道，如果两个人都执行最优策略，最大流的值和总费用分别为多少。

[codevs 1227]方格取数2

给出一个n*n的矩阵,每一格有一个非负整数Aij,(Aij <= 1000)现在从(1,1)出发,可以往右或者往下走,最后到达(n,n),每达到一格,把该格子的数取出来,该格子的数就变成0,这样一共走K次,现在要求K次所达到的方格的数的和最大

[BZOJ 3438]小M的作物

小M在MC里开辟了两块巨大的耕地A和B（你可以认为容量是无穷），现在，小P有n中作物的种子，每种作物的种子有1个（就是可以种一棵作物）（用1...n编号），现在，第i种作物种植在A中种植可以获得ai的收益，在B中种植可以获得bi的收益，而且，现在还有这么一种神奇的现象，就是某些作物共同种在一块耕地中可以获得额外的收益，小M找到了规则中共有m种作物组合，第i个组合中的作物共同种在A中可以获得c1i的额外收益，共同总在B中可以获得c2i的额外收益，所以，小M很快的算出了种植的最大收益，但是他想要考考你，你能回答他这个问题么？

[BZOJ1283] 序列

给出一个长度为的正整数序列Ci，求一个子序列，使得原序列中任意长度为M的子串中被选出的元素不超过K(K,M<=100) 个，并且选出的元素之和最大。

NekoMio's Blog

将 Hexo 部署到 Cloudflare Workers

0. 起因

1. 准备工作

2. 申请一个API key

3. 本地安装 Wrangler CLI 进行首次部署

安装 wrangler

初始化项目

修改配置

部署

4. 自定义 Router

计算导论与程序设计基础复习指北

观前提示

简介

计算机程序设计语言

计算模型

C语言 （划重点）

语法

1. 定义

2. 输入输出

流程控制

运算符

结构体

指针

函数传参与返回值

字符串

算法

1. 交换两个变量的值

2. 排序算法

3. 二分查找

写在最后

Min25 筛法的原理与应用

0. 定义

1. 用途

2. 条件

3. 做法

模板库

CDQ

点分治

Astar

模拟退火

莫队

离散化

Hash_Table

Treap

替罪羊树

FFT

NTT

树状数组

线段树

并查集

ST

KD-Tree

LCT

Dijkstra

SPFA

多项式

高斯消元

BSGS&exBSGS

KMP&EXKMP

线性筛

杜教筛

Miller_Robin

小米手环3 NFC 体验

前言

【NOI2017】游戏 2-SAT

题目描述

输入格式

输出格式

样例

样例输入

样例输出

数据范围与提示

题解

2-SAT 输出方案

清北夏令营前集训日记

2018-5-16

2018-5-17

2018-5-18

2018-5-20

C语言（划重点）