AGC014做题记录

貌似是比较水的一场 可是我依然8会做

 

C

发现除了第一步以外的走法都不会受到锁的影响并且一定选四个方向距离最近的径直走过去

那么第一步能走到的联通块取个min就好了

（我竟然第一发特别认真的写了一个DFS）

//Love and Freedom.
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#define inf 20021225
#define ll long long
#define N 810
#define pa pair<int,int>
using namespace std;
int read()
{
    int f=1,s=0; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9')    s=s*10+ch-'0',ch=getchar();
    return f*s;
}
int n,m,k,dx[4]={0,0,-1,1},dy[4]={1,-1,0,0};
int F(int x,int y){return min(min((x-1+k-1)/k,(y-1+k-1)/k),min((n-x+k-1)/k,(m-y+k-1)/k));}
int ans=inf; bool vis[N][N]; int dis[N][N];
queue<pa> q;
char ch[N];
int main()
{
    n=read(),m=read(),k=read(); int x,y;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",ch+1);
        for(int j=1;j<=m;j++)
            if(ch[j]=='#')    vis[i][j]=1;
            else if(ch[j]=='S') q.push(make_pair(i,j));
    }
    while(!q.empty())
    {
        pa tmp=q.front(); x=tmp.first,y=tmp.second; q.pop();
        ans=min(ans,F(x,y)+1);
        if(dis[x][y]==k)    continue;
        for(int i=0;i<4;i++)
        {
            int nx=x+dx[i],ny=y+dy[i];
            if(!nx||!ny||nx>n||ny>m||vis[nx][ny])    continue;
            vis[nx][ny]=1; dis[nx][ny]=dis[x][y]+1; q.push(make_pair(nx,ny));
        }
    }
    printf("%d\n",ans);
    return 0;
}

 

D

猜结论代师！

结论1：多于一个叶子就一定先手胜利

结论2：每次叶子可以把它的父亲拖下水两个一起删掉

写了一发竟然对了？？

后来看了一下证明：后手胜利当且仅当存在完美匹配。（先手选哪个后手直接匹配掉就完事了）

所以其实我就是写了个完备匹配/px

//Love and Freedom.
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#define inf 20021225
#define ll long long
#define N 100010
using namespace std;
int read()
{
    int f=1,s=0; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9')    s=s*10+ch-'0',ch=getchar();
    return f*s;
}
struct edge{int to,lt;}e[N<<1];
int in[N],cnt,leaf[N],del[N],d[N];
void add(int x,int y)
{
    e[++cnt].to=y; e[cnt].lt=in[x]; in[x]=cnt; d[x]++; if(d[x]>1)    leaf[x]=0;
    e[++cnt].to=x; e[cnt].lt=in[y]; in[y]=cnt; d[y]++; if(d[y]>1)    leaf[y]=0;
}
int win;
void dfs(int x,int fr)
{
    if(win)    return; int lf=0,all=0,de=0;
    for(int i=in[x];i;i=e[i].lt)
    {
        int y=e[i].to; if(y==fr)    continue;
        dfs(y,x); all++; lf+=leaf[y]; de+=del[y];
        if(win)    return;
    }
    if(lf>=2)    win=1;
    if(lf==1)    del[x]=1;
    else    leaf[x]=1;
}
int rt;
int main()
{
    int n=read();
    for(int i=1;i<n;i++)    add(read(),read());
    if(n==2)    return puts("Second"),0;
    for(int i=1;i<=n;i++)    rt=d[i]>=2?i:rt;
    dfs(rt,0); puts(win?"First":"Second");
    return 0;
}

 

E

别人的NOIP模拟题/kk

一点思路都没有（摔

首先观察到（我就没观察到）最后一步的那条边一定是删了又加上

于是我们考虑建出两棵树 红树和蓝树

我们到着做这个过程

我们发现我们可以删掉一条红边变成蓝边当且仅当他们路径上就一条红边

所以我们维护哪些边可以删 然后直接合并的时候把度数小的边改到度数大的边上就可以了

复杂度：O(nlg^2n)

当然还可以正着做 发现每次就是删边以后看有一条边上就被覆盖了一次然后求出最小值删掉即可

所以是树链剖分+平衡树维护

复杂度：O(nlg^3n)

我是必然不可能写第二个的/px

//Love and Freedom.
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<map>
#include<set>
#include<queue>
#define inf 20021225
#define ll long long
#define N 100100
#define pa pair<int,int>
#define fs first
#define se second
#define mp make_pair
using namespace std;
int read()
{
    int f=1,s=0; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9')    s=s*10+ch-'0',ch=getchar();
    return f*s;
}
map<pa,int> g;
multiset<int> ed[N];
queue<pa> nd;
void add(int x,int y)
{
    if(x==y) return; if(x>y) swap(x,y); ed[x].insert(y); ed[y].insert(x);
    g[mp(x,y)]++; if(g[mp(x,y)]==2)    nd.push(mp(x,y));
}
void del(int x,int y)
{
    ed[y].erase(ed[y].find(x)); if(x>y)    swap(x,y);
    if(g.count(mp(x,y))) g.erase(mp(x,y));
}
int main()
{
    int n=read();
    for(int i=1;i<=2*(n-1);i++)    add(read(),read());
    for(int i=1;i<n;i++)
    {
        while(1)
        {
            if(nd.empty())    return puts("NO"),0;
            int x=nd.front().fs,y=nd.front().se; nd.pop();
            if(!g.count(mp(x,y)))    continue;
            if(ed[x].size()<ed[y].size())    swap(x,y);
            for(multiset<int>::iterator it=ed[y].begin();it!=ed[y].end();it++)
            {
                int to=*it; del(y,to); add(x,to);
            }
            break;
        }
    }
    puts("YES");
    return 0;
}

 

F

神仙题/se

我们考虑递推来做

发现1对整个序列没有影响（它一定会在最后一次挪到第一个来）

于是我们考虑对2,...,n计算这个问题

设2,...,n的答案为T，在T-1步时它的第一个位置上的数是F。

可以发现f一定不等于2

可以这么考虑，如果已经是有序的了，那么T是不对的，T的数值其实应该是T-1

如果不是有序的，那么2后面一定存在一个low元素，它下一次会被移到首位从而序列不能再T步做到有序

接着我们考虑第是否需要多一步来让1变成首位。

结论是当1,2,f的顺序为(2,f,1)时答案为T，否则为T+1

你发现这个结论非常精妙

其实是对于{1,2,f}它们实际上是以循环的形式出现的

也就是(a,b,c)->(c,a,b)->(b,c,a)

具体证明呢 就是你分类讨论一下他们的大小关系对应的High和Low就好啦

于是呢这个玩意一边递推一边计算就好了qwq

//Love and Freedom.
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#define inf 20021225
#define ll long long
#define N 200010
using namespace std;
int read()
{
    int f=1,s=0; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9')    s=s*10+ch-'0',ch=getchar();
    return f*s;
}
int a[N],n,t[N],f[N];
bool check(int x,int y,int z){return (x<y&&y<z)||(y<z&&z<x)||(z<x&&x<y);}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)    a[read()]=i;
    for(int i=n-1;i;i--)
    {
        if(!t[i+1])
        {
            if(a[i]>a[i+1])    t[i]=1,f[i]=a[i+1];
        }
        else
        {
            if(check(f[i+1],a[i],a[i+1]))
                t[i]=t[i+1],f[i]=f[i+1];
            else
                t[i]=t[i+1]+1,f[i]=a[i+1];
        }
    }
    printf("%d\n",t[1]);
    return 0;
}