noip2019集训测试赛

Posted 2022-07-30 youddjxd

Problem A: Maze

Time Limit: 1000 ms Memory Limit: 256 MB

Description

考虑一个N×M的网格，每个网格要么是空的，要么是障碍物。整个网格四周都是墙壁（即第1行和第n行，第1列和第m列都是墙壁），墙壁有且仅有两处开口，分别代表起点和终点。起点总是在网格左边，终点总是在网格右边。你只能朝4个方向移动：上下左右。数据保证从起点到终点至少有一条路径。

从起点到终点可能有很多条路径，请找出有多少个网格是所有路径的必经网格。

Input

第一行包含两个整数 N,M，表示网格 N 行 M列。

接下来 N行，每行 M个字符，表示网格。‘#‘表示障碍物或墙壁，‘.‘表示空地。

Output

输出文件包含一个整数，必经点的个数。

Sample Input
7 7
#######
....#.#
#.#.###
#.....#
###.#.#
#.#....
#######

Sample Output
5

HINT

样例解释

(2, 1) (2, 2) (4, 4) (6, 6) (6, 7)

数据范围与约定

对于10%的数据， 3≤N,M≤50

对于50%的数据， 3≤N,M≤500

对于所有数据， 3≤N,M≤1000

Solution

先建个图，然后tarjan割点

割点的时候判断这个点在不在起点到终点的路上，如果不在就没必要算入答案。

#include<bits/stdc++.h>
using namespace std;
struct qwq
    int v;
    int nxt;
edge[4000001];
int head[1000001];
int cnt=-1;
void add(int u,int v)
    edge[++cnt].nxt=head[u];
    edge[cnt].v=v;
    head[u]=cnt;
 
int dfn[1000001];
int low[1000001];
int rt;
int ind;
int s,t;
bool pd[1000001];
bool tarjan(int u)
    dfn[u]=low[u]=++ind;
    int child=0;
    bool flag=false;
    for(int i=head[u];~i;i=edge[i].nxt)
        int v=edge[i].v;
        bool fflag=false;
        if(!dfn[v])
            fflag=tarjan(v);
            flag=flag||fflag;
            low[u]=min(low[u],low[v]);
            if(dfn[u]<=low[v]&&fflag)
                pd[u]=true;
            
        
        low[u]=min(low[u],dfn[v]);
    
    return flag||u==t;

bool mapn[1001][1001];
int movex[4]=0,1,0,-1;
int movey[4]=1,0,-1,0;
int main()
    memset(head,-1,sizeof(head));
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            char ch;
            cin>>ch;
            if(ch=='.')
                mapn[i][j]=true;
                if(j==1)
                    s=(i-1)*n+j;
                
                if(j==n)
                    t=(i-1)*n+j;
                
            
        
    
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            if(!mapn[i][j])continue;
            for(int k=0;k<4;++k)
                int x=i+movex[k],y=j+movey[k];
                if(x<1||y<1||x>n||y>m||!mapn[x][y])continue;
                add((i-1)*n+j,(x-1)*n+y);
            
        
    
    //cout<<s<<" "<<t<<endl;
    tarjan(s);
    int ans=0;
    for(int i=1;i<=n*m;++i)
        if(pd[i])
            ans++;
            //cout<<i<<endl;
        
    
    printf("%d\n",ans+1);

Problem B: 懒人跑步

Time Limit: 1000 ms Memory Limit: 256 MB

Description

在ZJU，每个学生都被要求课外跑步，并且需要跑够一定的距离 K，否则体育课会挂科。

ZJU有4个打卡点，分别标记为 p1,p2,p3,p4。每次你到达一个打卡点，你只需要刷一下卡，系统会自动计算这个打卡点和上一个打卡点的距离，并将它计入你的已跑距离。

系统把这4个打卡点看成一个环。 p1与 p2 相邻、 p2 与 p3 相邻、 p3 与 p4 相邻、 p4 与 p1 相邻。当你到达打卡点 pi时，你只能跑到与该打卡点相邻的打卡点打卡。

打卡点 p2是离宿舍最近的一个打卡点。CJB总是从 p2 出发，并回到 p2 。因为CJB很圆，所以他希望他跑的距离不少于 K，但又要尽量小。

Input

第一行为一个整数 T，表示数据组数。

对于每组数据，有5个正整数 K,d1,2,d2,3,d3,4,d4,1(1≤K≤10^18,1≤d≤30000)，表示至少要跑的距离和每两个相邻的打卡点的距离。

Output

对于每组数据，输出一个整数表示CJB最少需要跑多少距离。

Sample Input

1
2000 600 650 535 380

Sample Output

2165

HINT

样例解释

最优路径为 2?1?4?3?2

数据范围与约定

对于30%的数据， 1≤K≤30000,1≤d≤30000

对于100%的数据， 1≤K≤10^18,1≤d≤30000,1≤T≤10

Solution

首先我们显然可以在任意一条道路上来回摩擦

那么假设我们有一条长度为K的路径，设w=min(dis(1,2),dis(2,3))，肯定有一条长度为k+2w的路径

所以我们设dis[i][j]为到达某一个点，且dis[i][j]≡j(mod 2w)的最短距离

然后用类似最短路的方式更新，最后到达2号点的mod 2w的值最小的路径的就好了

#include<bits/stdc++.h>
using namespace std;
#define ll long long
struct data
    int p;
    int m;
;
int d[4];
ll dis[4][100001];
bool vis[4][100001];
void spfa(int w)
    memset(dis,0x7f,sizeof(dis));
    //memset(vis,0,sizeof(vis));
    queue<data> q;
    q.push(data1,0);
    dis[1][0]=0;
    vis[1][0]=true;
    while(!q.empty())
        int p=q.front().p,m=q.front().m;
        int nxt=(p+1)%4,pre=(p+3)%4;
        //cout<<p<<" "<<m<<" "<<nxt<<" "<<pre<<endl;
        q.pop();
        vis[p][m]=false;
        if(dis[p][m]+d[p]<dis[nxt][(m+d[p])%w])
            dis[nxt][(m+d[p])%w]=dis[p][m]+d[p];
            if(!vis[nxt][(m+d[p])%w])
                q.push(data(nxt,(m+d[p])%w));
                vis[nxt][(m+d[p])%w]=true;
            
        
        if(dis[p][m]+d[pre]<dis[pre][(m+d[pre])%w])
            dis[pre][(m+d[pre])%w]=dis[p][m]+d[pre];
            if(!vis[pre][(m+d[pre])%w])
                q.push(datapre,(m+d[pre])%w);
                vis[pre][(m+d[pre])%w]=true;
            
        
    

int main()
    int T;
    scanf("%d",&T);
    while(T--)
        ll k;
        scanf("%lld%d%d%d%d",&k,&d[0],&d[1],&d[2],&d[3]);
        int w=min(d[0],d[1]);
        spfa(w*2);
        while(dis[1][k%(w*2)]>k)k++;
        printf("%lld\n",k);
    

Problem C: 道路建设

Time Limit: 4000 ms Memory Limit: 512 MB

Sample Input

5 7
1 2 2
2 3 4
3 4 3
4 5 1
5 1 3
2 5 4
1 4 5
5
1 2
4 7
11 12
11 13
18 19

Sample Output

3
9
8
14
13

HINT

样例解释

解密后的询问为 (1,2),(1,4),(2,3),(3,5),(4,5)

修建道路最小费用的方案为 (1,2),(4,5),(2,1),(1,5),(5,4),(4,3),(1,2),(1,5),(3,4),(1,5),(5,2),(2,3),(3,4),(3,2),(2,5),(1,4)

数据规模与约定

子任务1（5分）： 1≤n,m,q≤1000,online=1

子任务2（11分）： 1≤n≤1000,1≤m,q≤10^5,online=0

子任务3（14分）： 1≤n≤1000,1≤m,q≤10^5,online=1

子任务4（21分）： 1≤n,m,q≤10^5,online=0

子任务5（49分）： 1≤n,m,q≤10^5,online=1

Solution

首先如果此题没有强制在线，我们可以用LCT模拟建立最小生成树的过程。

首先把边权从大到小排序，不断把边插入LCT中，

如果当前加入的边与原来的边构成了一个环，我们找到这个环上最大的边去掉，然后加入这条边。

现在我们要让他能够在线处理，那我们就建立一棵主席树来方便查询历史版本。

然后每次查询l,r只需要查询版本为l且小于等于r的边的和就可以了（因为在这个版本中比l小的还未加入进来）

有史以来写过的最恶心的题

#include<bits/stdc++.h>
using namespace std;
struct node
    int ch[2];
    int fa;
    int val;
    int tag;
    int mp;
t[300001];
bool nroot(int x)
    return t[t[x].fa].ch[0]==x||t[t[x].fa].ch[1]==x;

void pushup(int x)
    t[x].mp=x;
    int lc=t[x].ch[0],rc=t[x].ch[1];
    if(t[t[lc].mp].val>t[t[x].mp].val)t[x].mp=t[lc].mp;
    if(t[t[rc].mp].val>t[t[x].mp].val)t[x].mp=t[rc].mp;

void rev(int x)
    swap(t[x].ch[0],t[x].ch[1]);
    t[x].tag^=1;

void pushdown(int x)
    if(t[x].tag)
        if(t[x].ch[0])rev(t[x].ch[0]);
        if(t[x].ch[1])rev(t[x].ch[1]);
        t[x].tag=0;
    

void rotate(int x)
    int fa=t[x].fa;
    int gfa=t[fa].fa;
    bool k=t[fa].ch[1]==x;
    if(nroot(fa))t[gfa].ch[t[gfa].ch[1]==fa]=x;
    t[x].fa=gfa;
    t[fa].ch[k]=t[x].ch[k^1];
    if(t[x].ch[k^1])t[t[x].ch[k^1]].fa=fa;
    t[fa].fa=x;
    t[x].ch[k^1]=fa;
    pushup(fa);pushup(x);

int st[2000001];
void splay(int x)
    int y=x,z=0;
    st[++z]=y;
    while(nroot(y))
        st[++z]=y=t[y].fa;
    
    while(z)pushdown(st[z--]);
    while(nroot(x))
        int fa=t[x].fa;
        int gfa=t[fa].fa;
        if(nroot(fa))
            if((t[fa].ch[1]==x)^(t[gfa].ch[1]==fa))rotate(x);
            else rotate(fa);
        
        rotate(x);
    
    pushup(x);

void access(int x)
    int y=0;
    while(x)
        //cout<<y<<" "<<x<<" "<<t[x].fa<<endl;
        splay(x);
        t[x].ch[1]=y;
        pushup(x);
        y=x;
        x=t[x].fa;
    

void makeroot(int x)
    access(x);
    splay(x);
    rev(x);

void link(int x,int y)
    makeroot(x);
    t[x].fa=y;

int cutmax(int x,int y)
    makeroot(x);
    access(y);
    splay(y);
    x=t[y].mp;
    splay(x);
    t[t[x].ch[0]].fa=t[t[x].ch[1]].fa=0;
    t[x].ch[0]=t[x].ch[1]=0;
    return x;

struct qwq
    int u,v,w;
edge[1000001];
bool operator <(qwq a,qwq b)
    return a.w>b.w;

int fa[100001];
int findfa(int x)
    return fa[x]==x?x:fa[x]=findfa(fa[x]);

struct seg
    int l,r,val; 
tt[4000001];
int rt[10001];
int cnt;
void update(int now,int &root,int p,int v,int l,int r)
    root=++cnt;
    tt[root]=tt[now];
    tt[root].val+=v;
    if(l==r)return;
    int mid=(l+r)/2;
    if(p<=mid)update(tt[now].l,tt[root].l,p,v,l,mid);
    else update(tt[now].r,tt[root].r,p,v,mid+1,r);

int query(int now,int L,int R,int l,int r)
    if(now==0)return 0;
    if(L<=l&&r<=R)return tt[now].val;
    int mid=(l+r)/2;
    int ret=0;
    if(L<=mid)ret+=query(tt[now].l,L,R,l,mid);
    if(mid<R)ret+=query(tt[now].r,L,R,mid+1,r);
    return ret;

int main()
    int n,m,online;
    scanf("%d%d%d",&n,&m,&online);
    for(int i=1;i<=m;++i)
        scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
    
    sort(edge+1,edge+1+m);
    for(int i=1;i<=n;++i)fa[i]=i;
    int N=edge[1].w;
    for(int i=1;i<=m;++i)
        rt[edge[i].w]=rt[edge[i-1].w];
        int u=edge[i].u,v=edge[i].v;
        int x=findfa(u),y=findfa(v);
        int q;
        if(x==y)
            q=cutmax(u,v);
            update(rt[edge[i].w],rt[edge[i].w],t[q].val,-t[q].val,1,N);
        
        else 
            fa[x]=y;
            q=i+n;
        
        t[q].val=edge[i].w;
        t[q].mp=q;
        link(u,q);
        link(q,v);
        update(rt[edge[i].w],rt[edge[i].w],edge[i].w,edge[i].w,1,N);
    
    for(int i=N;i>=2;i--)
        if(!rt[i-1])
            rt[i-1]=rt[i];
        
    
    int q,last=0;
    scanf("%d",&q);
    while(q--)
        int l,r;
        scanf("%d%d",&l,&r);
        l-=last*online;
        r-=last*online;
        printf("%d\n",last=query(rt[l],1,r,1,N));