9.27下午考试(Nescafé 29杯模拟赛)
140pts(100+30+10)Rank3
前几天还考了一场，AK，没什么好总结的，所以就没写博客。
炸：
T2，模拟退火突然不会了，写个状压dp，排序边的时候sort的N而不是M。
这个坑经常出！！
T3，打表没有打全，规律推的有问题，本来应该加到5，我却加到了2。
这个注意着点就行了
我的变量名又开始各种鬼畜了。。。
由于教练让我写题解了，所以题解就搁下面了
rainbow
题目大意：笛卡尔坐标系中，x轴非负半轴上有7个在第一象限半圆，你需要把这7个半圆的半径增加一个相同的实数，使得这些半圆恰好覆盖线段\(y=h(0\le x\le x_0)\)
题解：由于答案是单调的（就是如果一个\(r_0\)是合法的答案，那么\(\forall r\ge r_0\)都有\(r\)是一个合法的答案）
所以可以通过二分答案来解决，二分这个\(r\)，然后算出所有的圆覆盖直线\(y=h\)的区域(一定是一个线段)，然后跑一遍区间求并即可。如果一个圆和线段相离，把这个区间设为\([-1,-1]\)即可(或者是别的奇奇怪怪的值都行)。注意不要计算两个圆之间的交点，不好写，有误差还容易写错
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#define six 6
#define seven 7
#define eight 8
#define hexo 1e-9//鬼畜变量名常量名系列程序之Nescafe29
using namespace std;
struct fuck
{
double x, r;
}a[10];
struct pdf
{
double l, r;
}s[10];
double h, x0;
bool ghj1222(const pdf &a, const pdf &b)
{
if (fabs(a.l - b.l) <= hexo)
return a.r < b.r;
return a.l < b.l;
}
bool valid(double ass)
{
//然后就是区间覆盖问题了你特么求交点干什么
//233333
for (int i = 1; i <= seven; i++)
{
double qtmd = (a[i].r + ass) * (a[i].r + ass) - h * h;
if (qtmd <= 0)
s[i].l = s[i].r = 123456789;
else
{
qtmd = sqrt(qtmd);
s[i].l = a[i].x - qtmd;
s[i].r = a[i].x + qtmd;
}
}
sort(s + 1, s + eight, ghj1222);
double l = s[1].l, r = s[1].r;
if (l > 0)
return false;
for (int i = 2; i <= seven; i++)
{
if (r >= x0)
return true;
if (s[i].l <= r)
r = max(s[i].r, r);
else
return false;
}
return r >= x0;
}
int main()
{
freopen("rainbow.in", "r", stdin);
freopen("rainbow.out", "w", stdout);
scanf("%lf%lf", &h, &x0);
for (int i = 1; i <= seven; i++)
scanf("%lf%lf", &a[i].x, &a[i].r);
double l = 0;
double r = 12345;//Very Safe!!!..........2333333qtmd
while (r - l > hexo)
{
double mid = (l + r) / 2;
if (valid(mid))
r = mid;
else
l = mid;
}
printf("%.2f\n", l);
fclose(stdin);
fclose(stdout);
return 0;
}
clover
题目大意：给定一张图，求一个图的分量使得这个分量内所有联通块的点权和为0，且最小化边权。
题解：本题可以随机化、模拟退火做，也可以状压dp
状压dp：由于\(N\le16\)所以可以状压dp做。令\(f[i]\)代表到达状态为i的最小花费，其中\(i\)的二进制第\(j\)位为1，则第\(j\)个点已经被选择，否则未被选择。首先\(f[0]=0\)，\(Ans=f[2^N-1]\)。由于是最小化某个数，所以f数组先初始化为极大值。考虑转移：首先一个转移肯定是往原状态里加一个连通块组成一个新状态，所以我们预处理出所有的连通块，保证这个连通块内所有的点和为0，且所有点之间仅由“属于这个连通块的边”联通。我们枚举所有的状态，先判断这个状态表示的点集内所有点权和是否为0，如果为0，那么在这个点集内跑一遍最小生成树。注意先把所有边sort一下，然后只对于起点和终点都属于这个点集内的边更新并查集，否则不去更新。最后处理出来最小生成树要检查一下这个点集内所有的点是否联通（也就是所有的点的父亲是否都是一个节点），如果是就返回最小生成树的边权即可，不是要返回这个转移不合法。记录所有合法的转移（记录点集和花费）。先枚举所有状态，然后枚举所有转移（因为一个状态一定是由一个编号比它小的状态转移过来的），（这里使用填表法）如果这个转移能够由某一个状态转移到这个状态（用二进制xjb判一下就行了）那么就计算出这个状态并转移即可。最后如果答案没有被更新，那么就是Impossible，否则输出答案即可。你也可以预先搜一下是否有解，有解条件是所有强连通分量内点权和都为0
模拟退火：下面是来自GMPotlc的模拟退火算法，请大家认真欣赏一下。
T2 : 正经（xjb）算法
根据题意 如果 x 点是可行的 那么我们只需要 让他们联通即可 那么我们就可以联想到
最小生成树 ， 然而事实 总是那么不尽如人意 ， duipai 发现 结果几乎全是错的
仔细思考发现 有这样一个 error ：
对于 两个 联通块 如果各自联通块的权值和 分别已经 为零了 那么我们就不在需要
去将这两个联通块 连在一起 ， 怎么解决这个问题呢 ？
聪明的人 都已经想到了 xjb 算法
我们 对于 克鲁斯卡尔 加边的时候 我们 xjb rand（）即可
然后 进行 300000 次即可 （当然更聪明的人 其实可以xjb 退火了）
这是我的状压dp
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int N, M, tot, g[20][20], val[20];
//第0位为第1个，第1位为第2个，最高位为第N个
struct edge
{
int u, v, w;
}a[200];
namespace Confusion
{
int st[65600], cost[65600], top, fa[20], f[65600];
int getf(int x)
{
return fa[x] == x ? x : fa[x] = getf(fa[x]);
}
bool cmp(const edge &a, const edge &b)
{
return a.w < b.w;
}
bool valid1(int fuck)
{
int ans = 0;
for (int i = 1; i <= N; i++, fuck >>= 1)
if (fuck & 1)
ans += val[i];
return ans == 0;
}
//表表表表表表表表表表表表表表表表表表表表表
int valid2(int fuck)
{
bool v[20];
memset(v, 0, sizeof(v));
for (int i = 1; i <= N; i++, fuck >>= 1)
if (fuck & 1)
{
v[i] = true;
fa[i] = i;
}
int ans = 0;
//说好的克鲁斯卡尔呢我为什么存的是邻接矩阵？？！？！！？？！？！？！？！？！？！？！？！？！？
//好了写了个边表
for (int i = 1; i <= M; i++)
{
if (v[a[i].u] == true && v[a[i].v] == true)
{
int x = getf(a[i].u), y = getf(a[i].v);
if (x != y)
{
fa[x] = y;
ans += a[i].w;
}
}
}
int common_father = -1;
for (int i = 1; i <= N; i++)
if (v[i] == true)
{
if (common_father == -1 || getf(i) == common_father)
common_father = getf(i);
else
return -1;
}
return ans;
}
int work()
{
sort (a + 1, a + 1 + M, Confusion::cmp);
tot = (1 << N) - 1;
for (int i = 1; i <= tot; i++)
if (valid1(i))
{
int res = valid2(i);
if (res >= 0)
{
st[++top] = i;
cost[top] = res;
}
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 1; i <= tot; i++)
{
for (int j = 1; j <= top; j++)
{
if ((i ^ st[j]) + st[j] == i)
f[i] = min(f[i], f[i ^ st[j]] + cost[j]);
}
}
return f[tot];
}
}
namespace Impossible
{
bool v[20];
int search(int x)
{
int ans = val[x];
v[x] = true;
for (int i = 1; i <= N; i++)
if (g[x][i] < 0x3f3f3f3f && v[i] == false)
ans += search(i);
return ans;
}
bool judge()
{
memset(v, 0, sizeof(v));
for (int i = 1; i <= N; i++)
if (v[i] == false)
if (search(i) != 0)
return false;
return true;
}
}
int main()
{
freopen("clover.in", "r", stdin);
freopen("clover.out", "w", stdout);
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++)
scanf("%d", &val[i]);
memset(g, 0x3f, sizeof(g));
for (int i = 1; i <= N; i++)
g[i][i] = 0;
for (int x, y, z, i = 1; i <= M; i++)
{
scanf("%d%d%d", &x, &y, &z);
x++;
y++;
a[i] = (edge){x, y, z};
g[x][y] = min(g[x][y], z);
g[y][x] = min(g[y][x], z);
}
if (Impossible::judge() == 0)
puts("Impossible");
else
printf("%d\n", Confusion::work());
fclose(stdin);
fclose(stdout);
return 0;
}
domine
题目大意：询问\(N\)个节点的AVL树的形状数。\(N\le 3000\)。
题解：我们不难想到一个dp的做法：令\(f[i][j]\)代表有i个节点的树的高度为\(j\)的方案数。不难写出转移方程为：
\(\displaystyle f[i][j]=\sum_{x+y=i-1}(f[x][j-1]*f[y][j-1]+f[x][j-2]*f[y][j-1]+f[x][j-1]*f[y][j-2])\)
枚举左子树的节点数为x，右子树的节点数为y，由于整棵树的高度为j，所以一定有一个子树高度为j-1，由于两个子树高度最多差1，所以另一个子树高度可以为j-1或j-2。所以有3种方案：左j-1右j-1，左j-2右j-1，左j-1右j-2。根据乘法原理，整棵树数量为两棵子树的数量相乘，根据加法原理，上面3中方案相加即可。
由于时间复杂度为\(O(n^3)\)，所以这里需要稍微优化一下。首先由于树不可能是一个链，我们先假设j枚举到30即可。把f数组打表之后发现j是随着i变化而变化，大概j是i的一个对数函数。每一个i对应存在\(f[i][j]\)长度区间最长为5，且每一个i存在第一个有数的j是i的二进制最高位的位置。所以暴力求i最高位即可，然后向后枚举5位即可。这个能优化到\(O(n^2)\)乘以一个常数，虽然比较慢，但是能卡进去。
还有这道题有一个小坑：题目并没有让你取模\(10^9\)输出，而是保留后9位。就是后9位有前导0也要输出。我们手动模拟发现，当\(n\ge38\)时候有\(Ans\ge10^9\)，所以判一下，如果\(n<38\)就直接输出，\(n\ge38\)就要恰好保留9位，保留前导0。如果使用printf函数输出整数就用%09lld或%09d即可保留前导0。
另外这题的答案是一个整数数列，在OEIS的编号为A006265，点击超链接即可查看有关信息：N个节点的高度平衡的AVL树的形状。
#include <iostream>
#include <cstdio>
#include <iomanip>
#define asshole 1000000000
using namespace std;
//由N个节点组成的高度为M的树的方案数(高度算上根节点)
long long f[3010][3010], ans[3010];
#define N 3000
int highbit(int x)
{
int ans = 0;
while (x > 0)
{
x >>= 1;
ans++;
}
return ans;
}
//orz applepi!!!
//#include <ctime>
int main()
{
// int fuckyou = clock();
// freopen("domine.in", "r", stdin);
// freopen("domine.out", "w", stdout);
f[0][0] = 1;
f[1][1] = 1;
ans[1] = 1;
for (int i = 2; i <= N; i++)
{
int fuck = highbit(i);
for (int j = fuck; j <= fuck + 4; j++)//展现出填表法的威力吧
{
for (int x = 0; x < i; x++)
{
int y = i - 1 - x;
f[i][j] = ((f[i][j] + f[x][j - 1] * f[y][j - 1] % asshole) % asshole + (f[x][j - 2] * f[y][j - 1] % asshole + f[x][j - 1] * f[y][j - 2] % asshole) % asshole) % asshole;
}
(ans[i] += f[i][j]) %= asshole;
}
}
int fuck = 2333;
while (2333)
{
scanf("%d", &fuck);
if (fuck == 0)
break;
if (fuck >= 38)
printf("%09lld\n", ans[fuck]);
else
printf("%lld\n", ans[fuck]);
}//WAWA Lian
// fprintf(stderr, "%d\n", clock() - fuckyou);
fclose(stdin);
fclose(stdout);
return 0;
}
