2018篮球冬令营报名流程
　1，登录我校官网www.cbadg.com,下载，认真填写并签字后，发送至邮箱：
　　2，我校工作人员会在收到报名资料的三个工作日内联系您，确定报名信息。
　　3，报名成功后，请在两日内将训练营报名费全款汇至我校指定账户，并将汇款凭证传真至我校8
　　汇款账户：
　　账户（一）
　　户名：东莞市启航体育活动策划有限公司
　　账号：02284
　　开户银行：农业银行东莞会展支行
　　账户（二）
　　户名：李林
　　账号：1392
　　开户银行：中信银行东莞东城支行
　　请在汇款时务必备注报名者姓名，方便我校财务第一时间查账，尽快完成报名手续
　　4，我校工作人员会在收到报名费的五个工作日内联系您，确认报名结果。
&&&&注：确认报名交费不予办理退营（含中途）退费。
　　&&1）Please visit the website of Dongguan Basketball School,and& downloadand fillout
　　&&& the registration form, then faxing to 8.
　　& 2）We&will contact and confirm with you within three days after receiving your
&&&&&&& &registration　form.
&&&& &3）Please remit the camp fee to following banking account within two days after
&　　confirmation of the registration,then faxing the remittance proof to 8.
　　汇款账户：
　　账户（一）
　　账户名称(Accountname)：东莞市启航体育活动策划有限公司
　　账号(Accountnumber)：02284
　　开户行(Bankofdeposit)：农业银行东莞南城支行
　　账户（二）
　　账户名称(Accountname)：李林
　　账号(Accountnumber）：1392
　　开户银行(Bankofdeposit）：中信银行东莞东城支行
　　4.Please make sure your name is on the remittance proof. We will confirm with youthe
　　successful registration within five days after receiving the camp fee.2018年兰州国际马拉松赛最新消息
【导语】：2018兰马成为国际金标赛事后，兰州市今年两会报告对其尤为关注，下面兰州本地宝带大家看看关于2018年兰州国际马拉松赛的最新消息。　　1月6日，兰州市发改委向兰州市十六届人大二次会议提交《关于兰州市2017年国民经济和社会发展计划执行情况及2018年国民经济和社会发展计划草案的报告（书面）》，报告提出，兰州市将着力办好2018年兰州国际马拉松赛。　　在国际田联官方网站在2017年12月公布的 2018 年竞赛数据中，2018 年兰州国际马拉松赛成为国际金标赛事，这是国内的第七个国际金标赛事。
相关推荐 &&兰州新区半程马拉松赛比赛奖励是多少？有完赛奖励吗？兰州本地宝小编为您解答。当美食和约会相遇，那么会擦出怎样的火花？兰州的这些约会必备的“网红”餐厅名单，千万别错过！~今年的8月28日是七夕佳节，七夕有什么好玩的活动呢？欢迎阅读兰州本地宝小编为您整理提供的2017兰州七夕活动汇总。以下是兰州本地宝小编给您整理的七夕前后的好电影，看看有没有你喜欢的，赶紧带着最爱的他/她去看吧！好消息！第七届中国兰州黄河文化旅游节20日开始啦！活动攻略在此！拿走不谢！看豪车赏名模！第八届兰州国际汽车博览会23日华丽登场！附观展指南兰州市首届青年职工联谊会(第二场)即将举办，什么时候可以报名，怎么报名，兰州本地宝小编为您解答，欢迎阅读。今年七夕节是8月28日，七夕节兰州有哪些相亲活动呢？欢迎阅读兰州本地宝小编整理提供的2017兰州七夕相亲活动盘点。七夕，让我陪你去看海！不愿再背负不浪漫罪名！今年的8月28日是七夕佳节，七夕有哪有景点退出优惠活动呢？欢迎阅读兰州本地宝小编为您整理提供的2017兰州七夕景点优惠活动汇总。兰州十一有哪些车展？在哪里举办？门票怎么获取？兰州本地宝小编为您解答！今年国庆兰州有什么演出活动？在哪里开展，门票怎么购买？兰州本地宝小编为您解答。上一篇文章：下一篇文章：猜你喜欢
甘肃兰州东立奥特莱斯国际美食节9月16日盛大开幕
19:43 来源：本地宝
2017兰州国庆活动汇总（持续更新）
11:45 来源：本地宝
2017国庆兰州周边旅游攻略
11:40 来源：本地宝
2017兰州国庆车展汇总
11:25 来源：本地宝
2017兰州国庆演出活动大全
11:18 来源：本地宝
2017兰州十一国庆车展门票免费领取
15:17 来源：本地宝
甘肃科技馆将于2017年的10月1日正式开馆
20:47 来源：本地宝
#地下8英里#2017全国赛10月4日兰州开赛
20:26 来源：本地宝
2017兰州9月演出活动推荐
13:44 来源：兰州本地宝
2017兰州十一国际汽车展览会（时间+地点+门票）
15:35 来源：本地宝
本地宝郑重声明：本文仅代表作者个人观点，与本地宝无关。其原创性及文中陈述内容未经本站证实，本地宝对本文及其中全部或者部分内容的真实性、完整性、及时性不作任何保证和承诺，请网友自行核实相关内容。
大家都爱看
BENDIBAO.COM 汇深网 版权所有2018冬令营模拟测试赛（三）
时间： 11:27:44
&&&& 阅读：35
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&2018冬令营模拟测试赛（三）
[Problem A]摧毁图状树
见“试题描述”
见“试题描述”
见“试题描述”
见“试题描述”
数据规模及约定
见“试题描述”
这题没想到贪心 QwQ，那就没戏了……
贪心就是每次选择一个最深的且没有被覆盖的点向上覆盖 \(k\) 层，因为这个“最深的没有被覆盖的点”不可能再有其它点引出的链覆盖它了，而它又不得不被覆盖，那么向上引出的链自然越长越好。
那么接下来就是如何用数据结构快速模拟这个过程。
我们考虑处理出 \(k = 1 \sim \mathrm{max}\{dep_i\}\)（即最大深度）的所有答案，我们需要努力构造方法使得对于一个 \(k\) 我们只会访问部分节点，而不是全部。考虑到叶子节点很特殊，怎么都需要算上它们，但每次遍历一遍所有叶子又非常费时，所以我们可以一开始从“最近的叶子距离等于 \(k\)”的节点出发，以深度为关键字放在堆里，每次拿出一个节点，如果它没有被覆盖，就往上跳 \(k\) 级祖先并把它加到堆里。
我们可以用线段树 + DFS 序查询每个节点是否被覆盖（一个节点被覆盖当且仅当它子树中被拿出来过的节点的深度和它的深度之差小于 \(k\)），倍增实现跳 \(k\) 级祖先，于是所有操作都是一个 \(\mathrm{log}n\)。
考虑堆里的节点个数。下面先不考虑叶子节点，因为我们事先把它们踢出去了，事后加上叶子个数就好了。先从树上删掉所有被我们选中的节点，那么剩下的每个连通块大小不会小于 \(k-1\)，再把那些点加回去，那么每个连通块大小不超过 \(k\)，而每个被选中的节点顶多提供一个不会被选中的 \(k\) 级祖先。所以算法遍历到的点数不超过 \(\sum_{k=1}^{\mathrm{max}\{dep_i\}} {\frac{(n-L)}{k}}\) 显然这是调和级数，可以把它看成 \(n \mathrm{log} n\)。
#include &iostream&
#include &cstdio&
#include &cstdlib&
#include &cstring&
#include &cctype&
#include &algorithm&
#include &vector&
#include &queue&
using namespace
#define rep(i, s, t) for(int i = (s); i &= (t); i++)
#define dwn(i, s, t) for(int i = (s); i &= (t); i--)
int read() {
int x = 0, f = 1; char c = getchar();
while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
return x *
#define maxn 100010
#define maxm 200010
#define maxlog 17
#define oo
int n, m, head[maxn], nxt[maxm], to[maxm];
void AddEdge(int a, int b) {
to[++m] = nxt[m] = head[a]; head[a] =
swap(a, b);
to[++m] = nxt[m] = head[a]; head[a] =
int q, que[maxn], cq, task[maxn], Ans[maxn];
int nearest[maxn], dep[maxn], mxd, clo, dl[maxn], dr[maxn], uid[maxn], fa[maxn][maxlog],
vector &int& Kfar[maxn];
void build(int u) {
uid[dl[u] = ++clo] =
rep(i, 1, maxlog - 1) fa[u][i] = fa[fa[u][i-1]][i-1];
nearest[u] = n + 1;
mxd = max(mxd, dep[u]);
for(int e = head[u]; e = nxt[e]) if(to[e] != fa[u][0]) {
fa[to[e]][0] =
dep[to[e]] = dep[u] + 1;
build(to[e]);
nearest[u] = min(nearest[u], nearest[to[e]] + 1);
if(nearest[u] == n + 1) nearest[u] = 0, cntl++;
int KthParent(int u, int k) {
rep(i, 0, maxlog - 1) if(k && i & 1) u = fa[u][i];
return u ? u : 1;
struct Seg {
int minv[maxn&&2];
Seg() { rep(i, 1, (maxn && 2) - 1) minv[i] = }
void modify(int o, int l, int r, int p, int tp) { // tp == 1 means add, tp == -1 means delete.
if(l == r) {
if(tp & 0) minv[o] = dep[uid[l]];
else minv[o] =
int mid = l + r && 1, lc = o && 1, rc = lc | 1;
if(p &= mid) modify(lc, l, mid, p, tp);
else modify(rc, mid + 1, r, p, tp);
minv[o] = min(minv[lc], minv[rc]);
int query(int o, int l, int r, int ql, int qr) {
if(ql &= l && r &= qr) return minv[o];
int mid = l + r && 1, lc = o && 1, rc = lc | 1, ans =
if(ql &= mid) ans = min(ans, query(lc, l, mid, ql, qr));
if(qr & mid) ans = min(ans, query(rc, mid + 1, r, ql, qr));
struct cmp {
bool operator () (const int& a, const int& b) const {
return dep[a] & dep[b];
priority_queue &int, vector &int&, cmp& Q;
int grasp[maxn],
void solve(int k) {
rep(i, 0, (int)Kfar[k].size() - 1) Q.push(Kfar[k][i]);
while(!Q.empty()) {
int u = Q.top(); Q.pop();
if(sg.query(1, 1, n, dl[u], dr[u]) & dep[u] + k || nearest[u] & k) continue;
grasp[++cntg] =
sg.modify(1, 1, n, dl[u], 1);
Q.push(KthParent(u, k));
Ans[k] = cntg +
while(cntg) sg.modify(1, 1, n, dl[grasp[cntg--]], -1);
int main() {
n = read();
rep(i, 1, n - 1) {
int a = read(), b = read();
AddEdge(a, b);
q = read();
rep(i, 1, q) {
que[i] = read();
task[i] = que[i] = que[i] &= mxd ? que[i] :
sort(task + 1, task + q + 1);
cq = unique(task + 1, task + q + 1) - task - 1;
rep(i, 1, n) Kfar[nearest[i]].push_back(i);
rep(i, 1, cq) solve(task[i]);
rep(i, 1, q) printf(&%d\n&, Ans[que[i]]);
[Problem B]排列统计
见“试题描述”
见“试题描述”
见“试题描述”
见“试题描述”
数据规模及约定
见“试题描述”
妈妈呀这题 dp 好神！思路很棒。
引用一下原题解的话“我们想进行 dp，必须设法避免指数级的状态设计。为了做到这一点，我们尝试枚举计算每个值对答案的贡献、每个位置对答案的贡献，发现怎么都避免不了指数级状态的支配。考虑换一种思路——枚举每个值在每个位置对答案产生的贡献！”
这样似乎“枚举”次数多了，也即进行 dp 的轮数多了，但是我们却可以把状态降成多项式级别的，神奇吧！
设 \(f(i, j, p, c)\) 表示进行了 \(i\) 轮交换；在目标位置前的比目标数字大的数的个数为 \(j\)；目标数字在目标位置左边时 \(p = 0\)，在目标位置上时 \(p = 1\)，在目标位置右边时 \(p = 2\)；目标位置上的数小于目标数字时 \(c = 0\)，等于目标数字时 \(c = 1\)，大于目标数字时 \(c = 2\)；在这种情况下的方案数。转移就是枚举每种数字之间的交换（即目标位置左边比目标数字小的数、左边大数、目标位置上的数、右边小数、右边大数、目标数字，详见代码注释）。
#include &iostream&
#include &cstdio&
#include &cstdlib&
#include &cstring&
#include &cctype&
#include &algorithm&
#include &vector&
#include &queue&
using namespace
#define rep(i, s, t) for(int i = (s); i &= (t); i++)
#define dwn(i, s, t) for(int i = (s); i &= (t); i--)
int read() {
int x = 0, f = 1; char c = getchar();
while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
return x *
#define maxn 110
#define MOD
#define LL long long
int n, K, A[maxn], f[maxn][maxn][3][3],
void upd(int& a, LL b) {
a = (b + a) % MOD;
int Pow(int a, int b) {
int ans = 1, t =
while(b) {
if(b & 1) ans = (LL)ans * t % MOD;
t = (LL)t * t % MOD; b &&= 1;
int main() {
n = read(); K = read();
rep(i, 1, n) A[i] = read();
rep(val, 1, n) rep(pos, 1, val) {
int _j = 0, _p, _c;
rep(i, 1, pos - 1) if(A[i] & val) _j++;
rep(i, 1, n) if(A[i] == val) {
if(i & pos) _p = 0;
if(i == pos) _p = 1;
if(i & pos) _p = 2;
if(A[pos] & val) _c = 0;
if(A[pos] == val) _c = 1;
if(A[pos] & val) _c = 2;
memset(f, 0, sizeof(f));
f[0][_j][_p][_c] = 1;
// printf(&start(%d, %d):\n&, val, pos);
rep(i, 0, K - 1) rep(j, 0, min(n - val, pos - 1)) rep(p, 0, 2) rep(c, 0, 2) if(f[i][j][p][c]) {
int now = f[i][j][p][c], ls = pos - 1 - j - (p == 0), ll = j, rs = val - 1 - ls - (c == 0), rl = n - val - ll - (c == 2);
/*printf(&f[%d][%d][%d][%d] = %d | %d %d %d %d\n&, i, j, p, c, f[i][j][p][c], ls, ll, rs, rl);
if(i == K) // */
// symbol && means &swap with&.
// left smaller && left smaller
if(ls) upd(f[i+1][j][p][c], (LL)now * ls * ls);
// left smaller && left larger
if(ls && ll) upd(f[i+1][j][p][c], (LL)now * ls * ll * 2);
// left smaller && number on position
if(ls) upd(f[i+1][j+(c==2)][p==1?0:p][0], (LL)now * ls * 2);
// left smaller && right smaller
if(ls && rs) upd(f[i+1][j][p][c], (LL)now * ls * rs * 2);
// left smaller && right larger
if(ls && rl) upd(f[i+1][j+1][p][c], (LL)now * ls * rl * 2);
// left larger && left larger
if(ll) upd(f[i+1][j][p][c], (LL)now * ll * ll);
// left larger && number on position
if(ll) upd(f[i+1][j-(c!=2)][p==1?0:p][2], (LL)now * ll * 2);
// left larger && right smaller
if(ll && rs) upd(f[i+1][j-1][p][c], (LL)now * ll * rs * 2);
// left larger && right larger
if(ll && rl) upd(f[i+1][j][p][c], (LL)now * ll * rl * 2);
// number on position && number on position
upd(f[i+1][j][p][c], now);
// number on position && right smaller
if(rs) upd(f[i+1][j][p==1?2:p][0], (LL)now * rs * 2);
// number on position && right larger
if(rl) upd(f[i+1][j][p==1?2:p][2], (LL)now * rl * 2);
// right smaller && right smaller
if(rs) upd(f[i+1][j][p][c], (LL)now * rs * rs);
// right smaller && right larger
if(rs && rl) upd(f[i+1][j][p][c], (LL)now * rs * rl * 2);
// right larger && right larger
if(rl) upd(f[i+1][j][p][c], (LL)now * rl * rl);
if(p != 1 && c != 1) { // (ONLY when y is not on position)
// val y && left smaller
if(ls) upd(f[i+1][j][0][c==1?0:c], (LL)now * ls * 2);
// val y && left larger
if(ll) upd(f[i+1][j-(p!=0)][0][c==1?2:c], (LL)now * ll * 2);
// val y && number on position
upd(f[i+1][j+(p==0&&c==2)][1][1], 2ll * now);
// val y && right smaller
if(rs) upd(f[i+1][j][2][c==1?0:c], (LL)now * rs * 2);
// val y && right larger
if(rl) upd(f[i+1][j+(p==0)][2][c==1?2:c], (LL)now * rl * 2);
// val y && val y
upd(f[i+1][j][p][c], now);
upd(ans, f[K][0][1][1]);
// printf(&add: %d\n&, f[K][0][1][1]);
ans = (LL)ans * Pow(Pow(n, K && 1), MOD - 2) % MOD;
printf(&%d\n&, ans);
[Problem C]归并排序
见“试题描述”
见“试题描述”
见“试题描述”
见“试题描述”
数据规模及约定
见“试题描述”
首先这题需要观察出一些性质：我们把归并排序最后可能排错的两个数看成一对数，对于一对数 \((a, b)\)，不妨令 \(a & b\)，因为大小关系是等概率出现的；那么当这对数经过归并排序之后的顺序是先 \(a\) 后 \(b\)，它们就有可能离得很远，但一定会保证 \(b\) 每时每刻都在 \(a\) 的右边；如果顺序是先 \(b\) 后 \(a\)，我们会发现，在每次归并的时候，如果 \(b\) 能进入序列（这时一定是另一半轮到了一个大于 \(b\) 的数 \(c\)），那么紧随其后的 \(a\) 更能进入序列，因为 \(a & b & c\)。
令 \(a_i(i \in [1, n])\) 表示排序前的排列。
接下来对于每个询问，假设询问的是位置 \(x\) 到位置 \(y\)，我们看两个数都比 \(a_x\) 小的数对（也即最大值比 \(a_x\) 小的数对），和两个数都比 \(a_x\) 大的数对（也即最小值比 \(a_x\) 大的数对），剩下的就是两个数“跨过”\(a_x\) 的数对。不难发现都比 \(a_x\) 小的数对肯定整对都在 \(a_x\) 的前面，都比 \(a_x\) 大的数对肯定都在 \(a_x\) 的后面，“跨过”\(a_x\) 的数对有 \(\frac{1}{2}\) 的概率有一个数在 \(a_x\) 前面，\(\frac{1}{2}\) 的概率都在 \(a_x\) 的后面，这样的话，组合数算一下方案数再除以 \(2\) 的幂就好了。
注意 \(a_x\) 所在对交换可能会导致情况不一样，记得讨论。
统计那个东西开两个树状数组分别维护数对中较小值和较大值就好了。
#include &iostream&
#include &cstdio&
#include &cstdlib&
#include &cstring&
#include &cctype&
#include &algorithm&
#include &vector&
#include &queue&
using namespace
#define rep(i, s, t) for(int i = (s); i &= (t); i++)
#define dwn(i, s, t) for(int i = (s); i &= (t); i--)
int read() {
int x = 0, f = 1; char c = getchar();
while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
return x *
#define maxn 70000
#define MOD
#define LL long long
#define pii pair &int, int&
#define x first
#define y second
#define mp(x, y) make_pair(x, y)
int n, bel[maxn], Arr[maxn];
pii A[maxn];
struct BitArray {
int C[maxn];
void upd(int x, int v) {
for(; x &= x += x & -x) C[x] +=
int sum(int x) {
int ans = 0;
for(; x -= x & -x) ans += C[x];
int Pow(int a, int b) {
int ans = 1, t =
while(b) {
if(b & 1) ans = (LL)ans * t % MOD;
t = (LL)t * t % MOD; b &&= 1;
int fac[maxn], ifac[maxn];
int calc(int n, int m) { return (LL)fac[n] * ifac[m] % MOD * ifac[n-m] % MOD; }
int main() {
n = read();
for(int i = 1; i &= i += 2) {
bel[i] = bel[i+1] = (i - 1 && 1) + 1;
// printf(&%d %d
%d %d\n&, i, i + 1, bel[i], bel[i+1]);
int x = read(), y = read();
Arr[i] = Arr[i+1] =
if(x & y) swap(x, y);
A[bel[i]] = mp(x, y);
mx.upd(y, 1); mn.upd(x, 1);
fac[0] = ifac[0] = 1;
rep(i, 1, n) fac[i] = (LL)fac[i-1] * i % MOD, ifac[i] = (LL)ifac[i-1] * Pow(i, MOD - 2) % MOD;
int q = read();
while(q--) {
int tp = read(), x = read(), y = read();
if(tp == 1) {
swap(Arr[x], Arr[y]);
if(bel[x] == bel[y]) continue;
mx.upd(A[bel[x]].y, -1); mn.upd(A[bel[x]].x, -1);
mx.upd(A[bel[y]].y, -1); mn.upd(A[bel[y]].x, -1);
A[bel[x]] = mp(min(Arr[(bel[x]&&1)-1], Arr[bel[x]&&1]), max(Arr[(bel[x]&&1)-1], Arr[bel[x]&&1]));
A[bel[y]] = mp(min(Arr[(bel[y]&&1)-1], Arr[bel[y]&&1]), max(Arr[(bel[y]&&1)-1], Arr[bel[y]&&1]));
// printf(&%d %d %d | %d %d %d\n&, bel[x], A[bel[x]].x, A[bel[x]].y, bel[y], A[bel[y]].x, A[bel[y]].y);
mx.upd(A[bel[x]].y, 1); mn.upd(A[bel[x]].x, 1);
mx.upd(A[bel[y]].y, 1); mn.upd(A[bel[y]].x, 1);
if(tp == 2) {
int alls, allb, rest, ans = 0;
if(Arr[x] == A[bel[x]].y) {
alls = mx.sum(Arr[x] - 1); allb = mn.sum(n) - mn.sum(Arr[x]); rest = (n && 1) - alls -
if((alls && 1) & y - 1 || (alls && 1) + rest & y - 1) puts(&0&);
else printf(&%lld\n&, (LL)calc(rest, y - 1 - (alls && 1)) * Pow(Pow(2, rest), MOD - 2) % MOD);
alls = mx.sum(A[bel[x]].x - 1); allb = mn.sum(n) - mn.sum(A[bel[x]].x); rest = (n && 1) - alls - allb - 1;
if((alls && 1) & y - 1 || (alls && 1) + rest & y - 1) ;
else ans += (LL)calc(rest, y - 1 - (alls && 1)) * Pow(Pow(2, rest + 1), MOD - 2) % MOD;
alls = mx.sum(A[bel[x]].y - 1); allb = mn.sum(n) - mn.sum(A[bel[x]].y); rest = (n && 1) - alls - allb - 1;
if((alls && 1) & y - 2 || (alls && 1) + rest & y - 2) ;
else (ans += (LL)calc(rest, y - 2 - (alls && 1)) * Pow(Pow(2, rest + 1), MOD - 2) % MOD) %= MOD;
printf(&%d\n&, ans);
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文地址：http://www.cnblogs.com/xiao-ju-ruo-xjr/p/8107720.html
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！兰州冬令营
& 标识：广告置顶
& 课程简介/地址/机构名称(第1页)
【培训机构&】
& 兰州市城关区渭源路十字97号航天510所办公大楼
& 兰州市城关区渭源路十字97号航天510所办公大楼
& 图书大厦15楼和西固城宝丽华708室和兰大萃英大厦705室
& 兰州市城关区雁滩莱茵小镇13#楼
本页面是兰州求艺网【兰州冬令营】频道，该频道已收录0条信息，为您提供最新的【兰州冬令营、寒假冬令营】相关培训机构和培训学校查询。欢迎学员在求艺网提交在线报名。
周边城市：热门城市：