[考试反思]1027csp-s模拟测试90：自我

其实这套题很好。

但是这次，在T1爆炸的同时，T2和T3并没有出现能弥补的表现。

在AK仍然存在的同时，我居然连一个AC都没有。

所以最后就是一无是处的一场。

考试结束前估分：100+100+30=230

结果T1和T2都没有A。。。

T1乖乖的按照题意打大模拟，没算复杂度，开心的一匹。。。

T2位运算判定锅了，判断两个数二进制下的某几位是否相同不能与运算完再与原数判。

看到这句红色加粗的话我自己也想笑了。。。怎么能做到这么蠢的啊。。？

思路倒是对的，炸了50分。

T3想到线段树的正解，但是感觉会严重炸精把线段树弄成炸精树，后来就开始yy题目里的八分树。

还有一个小时10分钟的时候我打完了T1T2然后T3的30分暴力也写完了。

此时脑子里有一个不能让自己相信的正解，以及不是很放心的T1T2。

很凌乱，然后我在再写30分的部分分和尝试打T3正解和检查T1T2之间徘徊。

但是这次T1T2没办法对拍（没有暴力。。。）

最后什么都没有干成。剩15分钟的时候决心打30部分分，结果没调出来。

菜，还是菜。

这一轮可能又要废了。。。。。

哎，还是少一点废话吧。。。也改变不了什么。。。

T1：新的世界

转化题意，是最短路。

不难发现更新的先后顺序与答案无关。

出题人精心构造数据，直接模拟T死，反顺序dfs能极快AC。。。

唉。。。

 #include<cstdio>
 #include<iostream>
 #include<queue>
 using namespace std;
 int n,m,A[][],L[][],r,c,l;
 const int xx[]={,,,-};
 const int yy[]={,-,,};
 #define tx x+xx[i]
 #define ty y+yy[i]
 struct P{
     int x,y,dt;
     friend bool operator<(P a,P b){
         return a.dt<b.dt;
     }
 };
 priority_queue<P>q;
 int main(){
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;++i)for(int j=;j<=m;++j)scanf("%d",&A[i][j]);
     scanf("%d%d%d",&r,&c,&l); L[r][c]=l; q.push((P){r,c,l});
     for(int i=;i<=n;++i)A[i][]=A[i][m+]=;
     for(int i=;i<=m;++i)A[][i]=A[n+][i]=;
     scanf("%d%d",&r,&c);
     while(!q.empty()){
         int x=q.top().x,y=q.top().y,dt=q.top().dt;q.pop();
         if(x==r&&y==c)return printf("%d\n",dt),;
         for(int i=;i<;++i)if(L[tx][ty]<dt-A[tx][ty])
             q.push((P){tx,ty,L[tx][ty]=dt-A[tx][ty]});
     }puts("");
 }

T2：邻面合并

采用8进制压位，一共8*3+1=25位

其中8个8进制数表示以某一个点为起点的连续段终点是几。

1～7分别对应2～8而终点是1的情况与该起点不存在的情况无法区分。

那么如果存在终点是1的话起点一定是1，特判，如果存在终点为1的话，那么就把状态数+(1<<24)

搜索得到，状态数只有1597个，不均匀的分布在256种限制里。

预处理两种状态之间转移的费用。枚举上下两层的决策即可。

 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<iostream>
 using namespace std;
 vector<int>v[];
 int ss[],se[],tp,cnt,ref[],L[],R[];
 int fee[][],dp[][],st[],ans=,n,m,x;
 void sch(int c){
     int s=,fs=;
     for(int i=;i<=tp;++i)for(int j=ss[i];j<=se[i];++j)s|=<<j-;
     for(int i=;i<=tp;++i)fs|=se[i]-<<*ss[i]-;
     if(tp&&ss[]==&&se[]==)fs|=<<;
     v[s].push_back(fs);
     for(int s=c+;s<=;++s)for(int e=s;e<=;++e)ss[++tp]=s,se[tp]=e,sch(e),tp--;
 }
 int main(){
     sch();
     for(int i=;i<;++i){
         L[i]=cnt+;
         for(int j=;j<v[i].size();++j)ref[++cnt]=v[i][j];
         R[i]=cnt;
     }
     for(int i=;i<=cnt;++i)for(int j=;j<=cnt;++j){
         int s=ref[j],sp=ref[j];
         for(int t=;t;--t,s>>=)if(s&)fee[i][j]++;
         s=ref[i];
         for(int t=;t;--t,s>>=,sp>>=)if(s&)if((s&)==(sp&))fee[i][j]--;
     }
     memset(dp,,sizeof dp); dp[][]=;
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;++i)for(int j=;j<=m;++j)scanf("%d",&x),st[i]|=x<<j-;
     for(int i=;i<=n;++i)for(int j=L[st[i-]];j<=R[st[i-]];++j)
         for(int k=L[st[i]];k<=R[st[i]];++k)
             dp[i][k]=min(dp[i][k],dp[i-][j]+fee[j][k]);
     for(int i=L[st[n]];i<=R[st[n]];++i)ans=min(ans,dp[n][i]);
     printf("%d\n",ans);
 }

T3：光线追踪

可以发现，每一个矩形生效的只有左，下两条边。

一条边当然在一段连续的角度露出。

在一个角度下多条边，被看到的一定是横/纵坐标最小的。

如果坐标相同，那么编号大的更优。

然后就是维护结构体的区间修改单点查询了。

对于横着和竖着的边分开维护，两个线段树即可（当然结构体封装。。。）

但是线段树当然不能基于浮点数，不然绝对就是个炸精树

所以把所有要用到的浮点数都算出来，sort+unique离散化

用long double 就不会炸精，做乘除是用1.0l而不是1.0（Paris和kx的exp）

特殊处理x=0和y=0，方法很多。

我的方法是存下所有x=0,y=0的点的当前最小的另一个坐标以及编号。

同时，x=0的不能直接放进树里因为算角度时除0会爆炸。

但是我们也不能把它直接扔掉不管因为0~rx的那一段横着的线段可能还有用。

所以我们把它强制设定为1e-7而不是0就好了。

其实没有那么难码。真心祝愿你不要炸精。

 #include<cstdio>
 #include<algorithm>
 #include<iostream>
 using namespace std;
 int opt[],ux[],uy[],dx[],dy[],tp,n,mnx0=1e9+,mnxo,mny0=1e9+,mnyo;
 long double r[];
 struct P{int ord,x;};
 P Max(P a,P b){return a.x<b.x?a:(a.x==b.x?(a.ord<b.ord?b:a):b);}
 int G(int p){return p>?:p;}
 struct Segment_Tree{
     int cl[],cr[];P w[];
     void build(int p,int l,int r){
         cl[p]=l;cr[p]=r;w[p]=(P){,};
         if(l==r)return;
         build(p<<,l,l+r>>);
         build(p<<|,(l+r>>)+,r);
     }
     void set(int p,int l,int r,int ord,int x){
         if(l<=cl[p]&&cr[p]<=r)return w[p]=Max(w[p],(P){ord,x}),(void);
         if(l<=cr[p<<])set(p<<,l,r,ord,x);
         if(r>=cl[p<<|])set(p<<|,l,r,ord,x);
     }
     P ask(int p,int pos){
         if(cl[p]==cr[p])return w[p];
         return Max(w[p],pos<=cr[p<<]?ask(p<<,pos):ask(p<<|,pos));
     }
 }X,Y;
 main(){//freopen("raytracing4.in","r",stdin);freopen("my.out","w",stdout);
     scanf("%d",&n);
     for(int i=;i<=n;++i){
         scanf("%d",&opt[i]);
         if(opt[i]==){
             scanf("%d%d%d%d",&dx[i],&dy[i],&ux[i],&uy[i]);
             if(dx[i])r[++tp]=.0L*dy[i]/dx[i],r[++tp]=.0L*uy[i]/dx[i],r[++tp]=.0L*dy[i]/ux[i];
             else r[++tp]=dy[i]/1e-7L,r[++tp]=uy[i]/1e-7L,r[++tp]=dy[i]/ux[i];
         }
         else {
             scanf("%d%d",&dx[i],&dy[i]);
             if(dx[i])r[++tp]=.0L*dy[i]/dx[i];
         }
     }sort(r+,r++tp);tp=unique(r+,r++tp)-r-;
     X.build(,,tp);Y.build(,,tp);
     for(int i=;i<=n;++i)if(opt[i]==){
         if(!dx[i])if(mnx0>=dy[i])mnx0=dy[i],mnxo=i;
         if(!dy[i])if(mny0>=dx[i])mny0=dx[i],mnyo=i;
         int x1=lower_bound(r+,r++tp,.0L*dy[i]/(dx[i]?dx[i]:1e-7L))-r,
             x2=lower_bound(r+,r++tp,.0L*uy[i]/(dx[i]?dx[i]:1e-7L))-r,
             x3=lower_bound(r+,r++tp,.0L*dy[i]/ux[i])-r;
         X.set(,x1,x2,i,dx[i]); Y.set(,x3,x1,i,dy[i]);
     }else{
         if(!dx[i]){printf("%d\n",mnxo);continue;}
         if(!dy[i]){printf("%d\n",mnyo);continue;}
         P a1=X.ask(,lower_bound(r+,r++tp,.0L*dy[i]/dx[i])-r),
           a2=Y.ask(,lower_bound(r+,r++tp,.0L*dy[i]/dx[i])-r);
         int fx=a1.x,fy=a2.x;
         if(1ll*fx*dy[i]==1ll*fy*dx[i])printf("%d\n",G(max(a1.ord,a2.ord)));
         else if(1ll*fx*dy[i]<1ll*fy*dx[i])printf("%d\n",G(a1.ord));
         else printf("%d\n",G(a2.ord));
     }
 }