【2020.01.09】NOIP提高组模拟赛(day1)
这次考得不理想，只做了前两题，后两题没时间做，说明做题速度偏慢。
source ： 100 + 20 + 0 + 0 = 120 rank7 十分不友好。
算了，进入正题
\(T1\)
传送门：[USACO17JAN]Cow Dance Show奶牛舞蹈
分析
一道清新的水题，很容易想到二分答案，易证满足单调性。
然后考虑可以接受的 \(check\)
根据时间维护一个小根堆，取堆首时判断。
然后——切了
代码略
\(T2\)
传送门：[USACO17JAN]Hoof, Paper, Scissor蹄子剪刀…
一道本应该是没多难的 \(DP\) ，然而考场时漏考虑一种转移，直接炸到 \(20\) 分。
根据题意，容易想到设状态 \(f_{i,j,k}\) 表示到第 \(i\) 回合，有改变 \(j\) 次的机会，且当前出 \(k\) （H/S/P，设为 \(1/2/3\) ）
考虑转移：
设 \(p\) ，\(q\) 表示不同于 \(k\) 的另外两个手势，\(win[i][j]\) 表示手势 \(i\) 能赢手势 \(j\) ，\(a[i]\) 表示当前 \(FJ\) 的手势 则有：
\[ f[i][j][k] = max(f[i-1][j-1][p] , f[i-1][j-1][q] , f[i-1][j][k]) + win[k][a[i]] \]
代码
#include<cstdio>
#include<iostream>
using namespace std;
const int N = 1e5;
int n , k , a[N + 5] , f[N + 5][25][4] , ans = 0 , p , q;
char ch;
int data[4][4];
int main()
{
// freopen("hps.in" , "r" , stdin);
// freopen("hps.out" , "w" , stdout);
scanf("%d%d" , &n , &k);
for(register int i = 1; i <= n; i++)
{
ch = getchar();
while (ch != 'H' && ch != 'P' && ch != 'S') ch = getchar();
if (ch == 'H') a[i] = 1;
else if (ch == 'P') a[i] = 2;
else if (ch == 'S') a[i] = 3;
}
data[1][3] = data[2][1] = data[3][2] = 1;
for(register int i = 1; i <= n; i++)
for(register int j = 1; j <= 3; j++)
f[i][0][j] = f[i - 1][0][j] + data[j][a[i]];
for(register int i = 1; i <= n; i++)
for(register int j = 1; j <= k; j++)
for(register int l = 1; l <= 3; l++)
{
if (l == 1) p = 2 , q = 3;
else if (l == 2) p = 1 , q = 3;
else if (l == 3) p = 1 , q = 2;
f[i][j][l] = max(f[i - 1][j][l] + data[l][a[i]], max(f[i - 1][j - 1][p] + data[l][a[i]] , f[i - 1][j - 1][q] + data[l][a[i]]));
}
for(register int i = 0; i <= k; i++)
for(register int j = 1; j <= 3; j++)
ans = max(f[n][i][j] , ans);
printf("%d" , ans);
}没了······
\(T3\)
传送门：[USACO17JAN]Cow Navigation奶牛导航
一道不是很难但码量大，细节多的题
\(tag\)：用 \(BFS\) 模拟做 \(DP\)
详细解析如下：
先转化：因为读入的地图缘故，所以我们设起点 \((n,1)\)，终点 \((1,n)\)
有两头奶牛，分别在 \((n,1)\) 处面向两个方向
且要注意：到终点的奶牛无视任何新增命令，不管另一头牛怎样，他都不动；若当前指令有一头牛会越界，也不动。（详细认真看题目）
设 \(f_{x1,y1,d1,x2,y2,d2}\) 表示牛一到达 \((x1,y1)\) 面向 \(d1\) ，牛二到达 \((x2,y2)\) 面向 \(d2\) 时的指令最短长度
因指令每个对答案的贡献都是 \(1\) ，所以可以用 \(BFS\) 来做最短路 ，边扩展边更新 \(dis\)
但实际上可以优化空间，那就是弄掉 \(d2\) 那一维
很好想，因为两头牛接受同一个指令，他们的方向是相对的，知道其中一头，就能知道另一头，取决于一开始的朝向
代码
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int N = 20;
int n , map[N + 5][N + 5] , head , tail , ans = 1e5;
int f[N + 5][N + 5][4][N + 5][N + 5][4] , vis[N + 5][N + 5][4][N + 5][N + 5][4];
int fx[4][2] = { -1 , 0 , 0 , 1 , 1 , 0 , 0 , -1 };
char ch;
struct node{
int x1 , y1 , d1 , x2 , y2 , d2;
}q[N * N * N * N * 16 + 10];
inline bool check(int x , int y , int xx , int yy)
{
return (x <= 0 || y <= 0 || x > n || y > n || map[x][y] == 1 || (xx == 1 && yy == n));
}
int main()
{
// freopen("cow.in" , "r" , stdin);
// freopen("cow.out" , "w" , stdout);
scanf("%d" , &n);
for(register int i = 1; i <= n; i++)
for(register int j = 1; j <= n; j++)
{
while (ch != 'E' && ch != 'H') ch = getchar();
if (ch == 'H') map[i][j] = 1;
ch = getchar();
}
q[++tail] = (node){n , 1 , 0 , n , 1 , 1};
memset(f , 0x3f , sizeof(f));
f[n][1][0][n][1][1] = 0;
vis[n][1][0][n][1][1] = 1;
while (head < tail)
{
struct node now = q[++head];
int x1 , y1 , d1 , x2 , y2 , d2;
d1 = now.d1 , d2 = now.d2;
x1 = now.x1 + fx[d1][0] , y1 = now.y1 + fx[d1][1];
if (check(x1 , y1 , now.x1 , now.y1)) x1 = now.x1 , y1 = now.y1;
x2 = now.x2 + fx[d2][0] , y2 = now.y2 + fx[d2][1];
if (check(x2 , y2 , now.x2 , now.y2)) x2 = now.x2 , y2 = now.y2;
if (f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1 < f[x1][y1][d1][x2][y2][d2] && vis[x1][y1][d1][x2][y2][d2] == 0)
{
q[++tail] = (node){x1 , y1 , d1 , x2 , y2 , d2};
f[x1][y1][d1][x2][y2][d2] = f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1;
vis[x1][y1][d1][x2][y2][d2] = 1;
}
d1 = (now.d1 + 1) % 4 , d2 = (now.d2 + 1) % 4;
x1 = now.x1 , y1 = now.y1 , x2 = now.x2 , y2 = now.y2;
if (f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1 < f[x1][y1][d1][x2][y2][d2] && vis[x1][y1][d1][x2][y2][d2] == 0)
{
q[++tail] = (node){x1 , y1 , d1 , x2 , y2 , d2};
f[x1][y1][d1][x2][y2][d2] = f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1;
vis[x1][y1][d1][x2][y2][d2] = 1;
}
d1 = (now.d1 + 3) % 4 , d2 = (now.d2 + 3) % 4;
x1 = now.x1 , y1 = now.y1 , x2 = now.x2 , y2 = now.y2;
if (f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1 < f[x1][y1][d1][x2][y2][d2] && vis[x1][y1][d1][x2][y2][d2] == 0)
{
q[++tail] = (node){x1 , y1 , d1 , x2 , y2 , d2};
f[x1][y1][d1][x2][y2][d2] = f[now.x1][now.y1][now.d1][now.x2][now.y2][now.d2] + 1;
vis[x1][y1][d1][x2][y2][d2] = 1;
}
}
for(register int i = 0; i < 4; i++)
for(register int j = 0; j < 4; j++)
ans = min(ans , f[1][n][i][1][n][j]);
printf("%d" , ans);
}\(T4\)
传送门：[USACO17JAN]Subsequence Reversal序列反转
解析如下：
似乎无从下手的题，其实是个很套路的区间 \(DP\)
根据数值只有 \(1~50\) 的特性，我们可以用神奇的操作弄掉所谓的翻转
废话不多说，且看
设 \(f_{i,j,down,up}\) 表示区间 \([i,j]\) ，数值取值范围 \([down,up]\) 时的最长子序列长度
然后区间 \(DP\) 套路转移，但两个区间是套在一起转移的
代码
#include<cstdio>
#include<iostream>
using namespace std;
const int N = 50;
int n , f[N + 5][N + 5][N + 5][N + 5] , a[N + 5] , Mx;
int main()
{
// freopen("reversal.in" , "r" , stdin);
// freopen("reversal.out" , "w" , stdout);
scanf("%d" , &n);
for(register int i = 1; i <= n; i++)
{
scanf("%d" , &a[i]);
for(register int down = 1; down <= a[i]; down++)
for(register int up = a[i]; up <= 50; up++)
f[i][i][down][up] = 1;
}
for(register int len1 = 2; len1 <= n; len1++)
for(register int i = 1; i <= n - len1 + 1; i++)
{
register int j = i + len1 - 1;
for(register int len2 = 2; len2 <= 50; len2++)
for(register int down = 1; down <= 51 - len2; down++)
{
register int up = down + len2 - 1 , Mx;
Mx = max(f[i][j][down + 1][up] , f[i][j][down][up - 1]);
Mx = max(f[i + 1][j][down][up] + (a[i] == down) , Mx);
Mx = max(f[i][j - 1][down][up] + (a[j] == up) , Mx);
Mx = max(f[i + 1][j - 1][down][up] + (a[j] == down) + (a[i] == up) , Mx);
f[i][j][down][up] = Mx;
}
}
printf("%d" , f[1][n][1][50]);
}