「考试 2019.7.19」悲伤的出题人

Posted 2022-05-01 lrefrain

　　题面出的很悲伤很悲伤，他绝对是失恋了。

　　一下就看到了三道题小的要死的64M内存，每道题开完数组我就立马算一次内存。所以没有出意料之外的MLE。

　第一题一开始花5min写了个30暴力，写的很顺。然后直接攻第二题，写了个Astar觉得AC稳了，可是有个地方没写下来（yet数组的问题），于是我爆了10分。所以死了，这时候还剩下两个小时。于是开始写第三题爆搜，写完之后想不出剩下的部分分，于是回到第一题准备死干，结果之想到一个倍增的 $ n^2logn $ 思路。

大致是这样的，设dp[i][j]为选了 $ 2^i $ 天，选了j块的方案数，倍增的话是 $ n^2logn $ 解决dp，紧接着二维背包，一维天数一维饼干数，所以可以用背包来 $ n^2logn $ 解决，这样的话估计只能跑过部分1500左右的测试点，最终T了40，但是有人用矩阵优化的转移，和我复杂度一样，是T90。

正解的话，大概就是设dp[i][j]是每天选大于1的饼干，选了i天，选了j块的方案数，那么那些选0块的天可以用插板法组合数学优化掉，也就是说。

$ ans= \sum \limits_i=1^n \ dp[i][n] C(D,i) $

可以 $ n^2 $ 得到答案。

 

第二题的话是真的水，我Astar打崩了，改了一下就A了。

 

第三题的话，暴力能拿到，正解是一个分类讨论。

细说一下：

如果把每张牌抽象成一条从b[i]指向a[i]的又向边，那么ans就是反转最少的边数使得至少存在n个点仅被一条边指向。

形成的联通块有一下三种情况。

1.边数=点数-1 ，形成一棵树，首先一次dfs，计算出每个点到跟的路径上能够指向根的边数g[x]，同时可以计算出所有的指向根的边的个数rf，所谓全部情况，可以想象成这棵树中哪个点不被指向，也就是有点数种情况，考虑如何计算这些情况，对于根来说，没得说，就是rf次反转，那么对于非根如何计算呢？

题解上说是dp，我认为他仅仅是一个简单的换根。

设x深度为d[x]。

也就是说考虑对于一个节点来说的话，他的子树中的边贡献不变，只有他到根的路径上所有的边需要反向与根的不被指向情况那么它的答案就是 rf-g[x]+(d[x]-g[x])=rf+d[x]-2*g[x].在相应的值域桶里+1。

2.边数=点数，形成一棵BaseTree，首先找到环（记得记录一下入边编号，不要死循环）。

发现非环边只能外向指，否则环内的边必然不能独占某个点，这样只剩下两种情况，顺环和逆环，分别统计即可。

3.点数<边数，这样至少有一个点必然被多于一条边占领，输出-1 -1即可。

 

总的来说比较可惜的是T2，差一点点就A了，下次应当注意一下代码准确度。

 

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cmath>
 4 #include<cstring>
 5 using namespace std;
 6 typedef long long ll;
 7 const int maxn=2005,mod=998244353;
 8 int n,M,dp[maxn][maxn],C[maxn],inv[maxn];
 9 ll D;
10 int qw(int a,int b)
11 
12     int ans=1;
13     for(;b;b>>=1,a=1LL*a*a%mod) if(b&1) ans=1LL*ans*a%mod;
14     return ans;
15 
16 void add(int &x,int b)
17 
18     x+=b;
19     if(x>=mod) x-=mod;
20     if(x<0) x+=mod;
21 
22 int dpit()
23 
24     for(register int j=0;j<=n;j++) dp[0][j]=1;
25     for(register int i=1;i<=min(D,(ll)n);i++)
26     
27         for(register int j=0;j<=n;j++)
28         
29             int l=max(0,j-M+1),r=j-1;
30             if(l==0) add(dp[i][j],dp[i-1][r]);
31             else add(dp[i][j],dp[i-1][r]-dp[i-1][l-1]);
32         
33         for(register int j=1;j<=n;j++) add(dp[i][j],dp[i][j-1]);
34     
35     int ans=0;
36     C[0]=1;
37     for(int i=1;i<=min((ll)n,D);i++)
38     
39         C[i]=1LL*C[i-1]*((D-i+1)%mod)%mod*inv[i]%mod;
40         ans=(ans+1LL*C[i]*(dp[i][n]-dp[i][n-1])%mod)%mod;
41     
42     return (ans%mod+mod)%mod;
43 
44 int main()
45 
46     inv[0]=1;
47     for(int i=1;i<=2000;i++) inv[i]=qw(i,mod-2);
48     while(scanf("%d%lld%d",&n,&D,&M)==3)
49     
50         if(n==0&&D==0&&M==0) break;
51         if(D==0||n==0||M==0||1LL*(n-1)/D+1>=M)
52         
53             puts("0");
54             continue;
55         
56         printf("%d\n",dpit());
57         memset(dp,0,sizeof(dp));
58         memset(C,0,sizeof(C));
59     
60     return 0;
61 

那一天我们许下约定

  1 #include<iostream>
  2 #include<cstring>
  3 #include<cstdio>
  4 #include<cstring>
  5 #include<queue>
  6 using namespace std;
  7 const int maxn=1e4+5,maxm=4e4+5,INF=0x3f3f3f3f;
  8 int T,n,m,x,y,z,dex,yes,tot=1,top,cld[maxn],yet[maxn],instack[maxn],stack[maxn],first[maxn];
  9 struct road
 10     int u,t,w,nxt;
 11 eage[maxm<<1];
 12 struct point1
 13     int id,dis;
 14     bool friend operator < (const point1 a,const point1 b)
 15     
 16         return a.dis>b.dis;
 17     
 18 dis[maxn];
 19 struct point2
 20     int id,h;
 21     bool friend operator < (const point2 a,const point2 b)
 22     
 23         return dis[a.id].dis+a.h>dis[b.id].dis+b.h;
 24     
 25 ;
 26 priority_queue<point1> q1;
 27 priority_queue<point2> q2;
 28 void add(int x,int y,int z)
 29 
 30     eage[++tot].u=x;
 31     eage[tot].t=y;
 32     eage[tot].w=z;
 33     eage[tot].nxt=first[x];
 34     first[x]=tot;
 35 
 36 void clear()
 37 
 38     top=0;tot=1;
 39     memset(first,0,sizeof(first));
 40     memset(cld,0,sizeof(cld));
 41     memset(yet,0,sizeof(yet));
 42     memset(instack,0,sizeof(instack));
 43 
 44 void dijk()
 45 
 46     memset(yet,0,sizeof(yet));
 47     for(int i=1;i<=n;i++) dis[i].id=i,dis[i].dis=INF;
 48     dis[1].dis=0;
 49     q1.push(dis[1]);
 50     while(q1.empty()==0)
 51     
 52         int x=q1.top().id;q1.pop();
 53         if(yet[x]) continue;
 54         yet[x]=1;
 55         for(int i=first[x];i;i=eage[i].nxt)
 56             if(dis[x].dis+eage[i].w<dis[eage[i].t].dis)
 57                 dis[eage[i].t].dis=dis[x].dis+eage[i].w,q1.push(dis[eage[i].t]);
 58     
 59     memset(yet,0,sizeof(yet));
 60 
 61 int work(int st)
 62 
 63     while(q2.empty()==0) q2.pop();
 64     point2 x,tmp;
 65     x.id=st;x.h=0;
 66     q2.push(x);
 67     int ans=INF;
 68     while(q2.empty()==0)
 69     
 70         x=q2.top();q2.pop();
 71         yet[x.id]=1;
 72         if(x.id==1)
 73         
 74             ans=x.h;
 75             break;
 76         
 77         for(int i=first[x.id];i;i=eage[i].nxt)
 78             if(i!=dex&&yet[eage[i].t]==0)
 79             
 80                 tmp.id=eage[i].t;
 81                 tmp.h=eage[i].w+x.h;
 82                 q2.push(tmp);
 83             
 84     
 85     memset(yet,0,sizeof(yet));
 86     return ans;
 87 
 88 void Astar()
 89 
 90     dijk();
 91     int ans=INF;
 92     for(int i=first[1];i;i=eage[i].nxt)
 93     
 94         dex=i^1;
 95         int t=eage[i].t,d=work(t)+eage[i].w;
 96         ans=min(d,ans);
 97     
 98     printf("%d\n",ans>10000000?-1:ans);
 99     return ;
100 
101 int main()
102 
103     scanf("%d",&T);
104     while(T--)
105     
106         scanf("%d%d",&n,&m);
107         while(m--)
108         
109             scanf("%d%d%d",&x,&y,&z);
110             add(x,y,z);add(y,x,z);
111         
112         Astar();
113         clear();
114     
115 

那一天她离我而去

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=1e5+5,mod=998244353;
int T,n,tot,dex,sum,cnt,res,rt,x,y,yet[maxn<<1],vis[maxn<<1],first[maxn<<1];
vector<int> id;
struct Road
    int u,t,w,nxt;
eage[maxn<<1];
struct Base_Tree
    int ans,flag,yet[maxn<<1],fa[maxn<<1],dir[maxn<<1];
    vector<int> loop,dr,id;
    void init(int x)
    
        flag=0;
        Get_loop(x,tot+3);
        memset(yet,0,sizeof(yet));
        for(int i=0;i<loop.size();i++)
        
            yet[loop[i]]=1;
            if(dr[i]==1) ans++;
        
        ans=min(ans,(int)loop.size()-ans);
        if(ans==loop.size()-ans) res=1LL*res*2%mod;
        for(int i=0;i<loop.size();i++) dfs(loop[i],0);
        rt+=ans;
        clear();
    
    void clear()
    
        ans=flag=0;
        for(int i=0;i<id.size();i++) yet[id[i]]=fa[id[i]]=dir[id[i]]=0;
        loop.clear();dr.clear();id.clear();
    
    void Get_loop(int x,int f)
    
        yet[x]=1;
        for(int i=first[x];i;i=eage[i].nxt)
        
            if(i!=(f^1)&&flag==0)
            
                int t=eage[i].t;
                if(yet[t])
                
                    for(;x!=t;x=fa[x])
                    
                        dr.push_back(dir[x]);
                        loop.push_back(x);
                    
                    dr.push_back(eage[i].w);
                    loop.push_back(t);
                    flag=1;
                
                else fa[t]=x,dir[t]=eage[i].w,Get_loop(t,i);
            
        
    
    void dfs(int x,int f)
    
        id.push_back(x);
        for(int i=first[x];i;i=eage[i].nxt)
            if(yet[eage[i].t]==0&&eage[i].t!=f)
            
                if(eage[i].w==1) ans++;
                dfs(eage[i].t,x);
            
    
bt;
struct Simple_Tree
    int rf,ans[maxn<<1],yet[maxn<<1],g[maxn<<1],d[maxn<<1],l[maxn<<1];
    vector<int> id;
    void init(int x)
    
        dfs(x,0);
        lsdfs(x,0);
        redfs(x,0);
        for(int i=0,flag=1;i<=cnt;i++)
            if(ans[i])
            
                if(flag)
                
                    rt+=i;
                    res=1LL*res*ans[i]%mod;
                    flag=0;
                
                ans[i]=0;
            
        clear();
    
    void clear()
    
        rf=0;
        for(int i=0;i<id.size();i++) yet[id[i]]=g[id[i]]=d[id[i]]=l[id[i]]=0;
        id.clear();
    
    void dfs(int x,int fa)
    
        id.push_back(x);
        for(int i=first[x];i;i=eage[i].nxt)
            if(eage[i].t!=fa)
            
                int t=eage[i].t;
                l[t]=l[x]+1;
                d[t]=d[x];
                if(eage[i].w==1) rf++,d[t]++;
                dfs(t,x);
            
    
    void lsdfs(int x,int fa)
    
        g[x]=rf+l[x]-2*d[x];
        for(int i=first[x];i;i=eage[i].nxt)
            if(eage[i].t!=fa)
                lsdfs(eage[i].t,x);
    
    void redfs(int x,int fa)
    
        ans[g[x]]++;
        for(int i=first[x];i;i=eage[i].nxt)
            if(eage[i].t!=fa)
                redfs(eage[i].t,x);
    
st;
void add(int x,int y,int z)

    eage[++tot].u=x;
    eage[tot].t=y;
    eage[tot].w=z;
    eage[tot].nxt=first[x];
    first[x]=tot;

void clear()

    tot=1;sum=0;
    for(int i=0;i<id.size();i++) yet[id[i]]=vis[id[i]]=first[id[i]]=0;
    id.clear();

void dfs(int x)

    vis[x]=1;dex++;
    for(int i=first[x];i;i=eage[i].nxt,cnt++)
        if(vis[eage[i].t]==0)
            dfs(eage[i].t);

void doit()

    res=1;rt=0;
    for(int i=1;i<=(n<<1);i++)
        if(yet[i]&&vis[i]==0)
        
            dex=cnt=0;
            dfs(i);
            cnt>>=1;
            if(cnt>=dex+1)
            
                res=rt=-1;
                break;
            
            if(cnt==1&&dex==2) continue;
            if(cnt==dex) bt.init(i);
            if(cnt==dex-1) st.init(i);
        
    printf("%d %d\n",rt,res);

int main()

    tot=1;
    scanf("%d",&T);
    while(T--)
    
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        
            scanf("%d%d",&x,&y);
            add(x,y,1);add(y,x,-1);
            if(yet[x]==0) sum++,yet[x]=1;
            if(yet[y]==0) sum++,yet[y]=1;
            id.push_back(x);id.push_back(y);
        
        if(sum<n)
        
            puts("-1 -1");
            clear();
            continue;
        
        doit();
        clear();
    

哪一天她能重回我身边