[考试反思]1029csp-s模拟测试92:弱智

我只能这么评价我自己。

看这个提交时间。。。我没话可说。。。

T1半个世界都A了还是切不掉。又一次挂细节。

T2不会证明的乱搞(虽然可以证明)A了没什么可说的算是水过。

T3之前水过的题(打的次正解)然后不会二进制分组跑图导致暴力都不会。

但是名次上难得能看了一次,但其实远不应该如此。

剩下的70分钟还是一点有效的正事都没干。。。

调整状态,马上就要11月份了啊。。。

T1:数列

ex_gcd。在ax+by=c有解的情况下关于x总代价是三个一次函数,先降中间未知后升。

可以三分。但是更简单的就是找到xy的最小非负整数和最大负整数,一共4个点取最优。

这样的话这4个点其实就是函数的两个拐点最近的整点。

应该没人像我一样傻逼写最小非负整数的时候没有%p+p%p而是直接%p。我是傻子。

 1 #include<cstdio>
 2 #define int long long
 3 void ex_gcd(int a,int b,int &x,int &y){
 4     if(!b)return x=1,y=0,(void)0;
 5     ex_gcd(b,a%b,x,y);
 6     int r=x;x=y;y=r-a/b*x;
 7 }
 8 int gcd(int a,int b){return b?gcd(b,a%b):a;}
 9 int _abs(int x){return x>0?x:-x;}
10 int _min(int a,int b){return a<b?a:b;}
11 main(){
12     int n,a,b,p,g,ans=0,X,Y,x,y,tx,ty,ta;
13     scanf("%lld%lld%lld",&n,&a,&b);
14     g=gcd(a,b);a/=g;b/=g;
15     ex_gcd(a,b,X,Y);
16     while(n--){
17         scanf("%lld",&p);
18         if(p%g)return puts("-1"),0;
19         p/=g;x=X*p;y=Y*p;ta=1e18;
20         tx=(x%b+b)%b;ty=(p-tx*a)/b;ta=_min(_abs(tx)+_abs(ty),ta);
21         tx-= b;ty=(p-tx*a)/b;ta=_min(_abs(tx)+_abs(ty),ta);
22         ty=(y%a+a)%a;tx=(p-ty*b)/a;ta=_min(_abs(tx)+_abs(ty),ta);
23         ty-=a ;tx=(p-ty*b)/a;ta=_min(_abs(tx)+_abs(ty),ta);
24         ans+=ta;
25     }printf("%lld\n",ans);
26 }

T2:数对

如果不考虑可以换顺序的话,就是《队长快跑》带权值的原题。

线段树优化dp,单点修改,区间加,区间查询max。

考虑怎么换顺序。

两个点会相互影响决策,要么是$a_i<b_j&&b_i<a_j$这样的话$i$必须在$j$前面。(题解的符号写反了)

还有一种就是完全相反。

再一种就是$a_i<b_j&&a_j<b_i$这样的话两个互相包容都可以选,换顺序没有影响。

所以其实只有前两种情况真正限制了它们的关系。

所以直接按照a+b排序就能保证上述顺序对的点顺序是对的。

也可以用max/min比较一下,不过这样的话需要第二关键字,随便弄一个都对。

试了一下用map迭代器遍历来直接离散化,没锅,挺帅的。

 1 #include<cstdio>
 2 #include<map>
 3 #include<algorithm>
 4 using namespace std;
 5 map<int,int>M;
 6 struct P{
 7     int a,b;long long w;
 8     friend bool operator<(P x,P y){
 9         int mx=max(x.b,x.a),my=max(y.b,y.a);
10         return mx<my||(mx==my&&x.b<y.b);
11     }
12 }p[100005];
13 struct Segment_Tree{
14     int cl[800005],cr[800005];long long w[800008],lz[800008];
15     void build(int p,int l,int r){
16         cl[p]=l;cr[p]=r;
17         if(l==r)return;
18         build(p<<1,l,l+r>>1);
19         build(p<<1|1,(l+r>>1)+1,r);
20     }
21     void down(int p){
22         lz[p<<1]+=lz[p];lz[p<<1|1]+=lz[p];
23         w[p<<1]+=lz[p];w[p<<1|1]+=lz[p];
24         lz[p]=0;
25     }
26     long long ask(int p,int l,int r){
27         if(l<=cl[p]&&cr[p]<=r)return w[p];
28         if(lz[p])down(p);
29         return max(l<=cr[p<<1]?ask(p<<1,l,r):0ll,r>cr[p<<1]?ask(p<<1|1,l,r):0ll);
30     }
31     void chg(int p,int pos,long long v){//if(p==1)printf("->:%d %lld\n",pos,v);
32         if(cl[p]==cr[p])return w[p]=max(w[p],v),(void)0;
33         if(lz[p])down(p);
34         if(pos<=cr[p<<1])chg(p<<1,pos,v);
35         else chg(p<<1|1,pos,v);
36         w[p]=max(w[p<<1],w[p<<1|1]);
37     }
38     void modify(int p,int l,int r,long long v){//if(p==1)printf("+:%d %d %lld\n",l,r,v);
39         if(l<=cl[p]&&cr[p]<=r)return lz[p]+=v,w[p]+=v,(void)0;
40         if(lz[p])down(p);
41         if(l<=cr[p<<1])modify(p<<1,l,r,v);
42         if(r>cr[p<<1])modify(p<<1|1,l,r,v);
43         w[p]=max(w[p<<1],w[p<<1|1]);
44     }
45 }T;
46 int main(){int n,cnt=0;//freopen("pair.in","r",stdin);
47     scanf("%d",&n);
48     for(int i=1;i<=n;++i)scanf("%d%d%lld",&p[i].a,&p[i].b,&p[i].w),M[p[i].a],M[p[i].b];
49     for(map<int,int>::iterator it=M.begin();it!=M.end();++it)(*it).second=++cnt;
50     for(int i=1;i<=n;++i)p[i].a=M[p[i].a],p[i].b=M[p[i].b];
51     T.build(1,1,cnt); sort(p+1,p+1+n);
52     //for(int i=1;i<=n;++i)printf("%d %d %lld\n",p[i].a,p[i].b,p[i].w);
53     for(int i=1;i<=n;++i)
54         if(p[i].a<p[i].b)T.modify(1,p[i].a+1,p[i].b,p[i].w),T.chg(1,p[i].a,T.ask(1,1,p[i].a)+p[i].w);
55         else T.chg(1,p[i].a,T.ask(1,1,p[i].b)+p[i].w);
56     printf("%lld\n",T.ask(1,1,cnt));
57 }

T3:最小距离

思维严重僵化。Dijkstra原来可以跑多源最短路啊

然后这题就没了,所有特殊点为源点跑最短路,记录来源。

如果一条边两端的点来源不同,那么就是把两个源点连起来了,更新答案。

 1 #include<cstdio>
 2 #include<queue>
 3 using namespace std;
 4 #define LL long long
 5 LL min(LL a,LL b){return a<b?a:b;}
 6 struct P{
 7     int p,s;LL d;
 8     friend bool operator<(P a,P b){
 9         return a.d>b.d;
10     }
11 };priority_queue<P>q;
12 int n,m,Q,fir[200005],l[400005],to[400005],w[400005],cnt=1,ps[200005],tp,s[200005];
13 LL dt[200005],ans[200005];
14 void link(int a,int b,int v){l[++cnt]=fir[a];fir[a]=cnt;to[cnt]=b;w[cnt]=v;}
15 int main(){//freopen("distance.in","r",stdin);
16     scanf("%d%d%d",&n,&m,&Q);
17     for(int i=1;i<=n;++i)dt[i]=ans[i]=10000000000000000;
18     for(int i=1;i<=Q;++i)scanf("%d",&ps[i]),q.push((P){ps[i],s[ps[i]]=ps[i],dt[ps[i]]=0});
19     for(int i=1,a,b,v;i<=m;++i)scanf("%d%d%d",&a,&b,&v),link(a,b,v),link(b,a,v);
20     while(!q.empty()){
21         int p=q.top().p,S=q.top().s;LL d=q.top().d;q.pop();
22         if(d!=dt[p])continue;
23         for(int j=fir[p];j;j=l[j])if(dt[to[j]]>d+w[j])
24             q.push((P){to[j],s[to[j]]=S,dt[to[j]]=d+w[j]});
25     }
26     for(int i=1;i<=m;++i)if(s[to[i<<1]]!=s[to[i<<1|1]])
27         ans[s[to[i<<1|0]]]=min(ans[s[to[i<<1|0]]],dt[to[i<<1]]+w[i<<1]+dt[to[i<<1|1]]),
28         ans[s[to[i<<1|1]]]=min(ans[s[to[i<<1|1]]],dt[to[i<<1]]+w[i<<1]+dt[to[i<<1|1]]);
29     for(int i=1;i<=Q;++i)printf("%lld ",ans[ps[i]]);
30 }

原文地址:https://www.cnblogs.com/hzoi-DeepinC/p/11758017.html

时间: 2024-10-09 02:20:01

[考试反思]1029csp-s模拟测试92:弱智的相关文章

csp-s模拟测试92

csp-s模拟测试92 关于$T1$:最短路这一定建边最短路. 关于$T2$:傻逼$Dp$这一定线段树优化$Dp$. 关于$T3$:最小生成树+树P+换跟一定是这样. 深入(?)思考$T1$:我是傻逼. 深入(?)思考$T2$:我是天才! 深入(?)思考$T3$:我是天才! 100 01:14:19 10 02:36:26 15 03:19:48 125 03:19:48 事实证明我是傻逼. A. 数列 故意删掉负数读入$Rp--$ $Exgcd$,对绝对值大力分类讨论,一次函数求最值. 考场死

csps模拟测试92反思

连着挂了三天T1了. 89: SPFA$vst$数组没清空 90:调试的时候多删了一句代码 91:没开$long long$ 我真是废物. 原文地址:https://www.cnblogs.com/hzoi-kx/p/11757600.html

[考试反思]0929csp-s模拟测试55:沦陷

菜得过分. 面对T1的大板子不知所措,然后T2的贪心不小心把排序语句删了... T1这种大模板啊...其实我是觉得我能打出来的,然后先用一个小时码了一个2k. 然后做T2想贪心就出来了.十分钟码完T3暴力之后回T1打对拍瞬间爆炸. 于是又重新打了一个2k,WA0.对拍发现. 然后考试就没几分钟了交暴力走了. 不要打完就跑,记得早点对拍改进思路. T1: 的确是挺裸的线段树.离散化或者权值线段树都可以. 但是考场上两个都打出来都死了. 最后用离散化A的. 1 #include<cstdio> 2

[考试反思]1002csp-s模拟测试56:凌乱

放假回来状态回升??(玩够了-但是稍困) T1打的不完全对,但是过掉了.很快的想到了二分吧喇叭啦.. 然后T2也挺快想出来了但是挂细节没发现,考试快结束的时候才发现出锅了. 改了过来是正解,但是出题人无良卡了线段树强制树状数组,T了一个子任务,卡常到飞起. T3暴力没什么问题. 卡常是一种习惯.要注意题目数据范围观察是否卡常. T1: 所有的决策都是一条一次函数. 分两类,斜率正或斜率非负. 如果第二类的直线里有在T=0时符合要求的,那么答案就是0,所以check(0)一下. 如果非负的直线都在

[考试反思]1003csp-s模拟测试58:沉淀

稳住阵脚. 还可以. 至少想拿到的分都拿到了,最后一题的确因为不会按秩合并和线段树分治而想不出来. 对拍了,暴力都拍了.挺稳的. 但是其实也有波折,险些被卡内存. 如果内存使用不连续或申请的内存全部使用的话,切记计算内存,一点都不能开大. T1: 直接根号筛,拿map也能过. 遍历map直接begin和end啊... 1 #include<cstdio> 2 int Cnt[202]; 3 struct hash_map{ 4 int cnt,fir[10000020],l[6666666],

[考试反思]0114省选模拟7:迷离

这次考得相对不错,但是没什么水准. 只不过记得T1这道原题而已.虽说我忘了怎么做,而且数据范围不一样...差不多是从头想的. 但是并没有AC,像个弱智一样,有两个细节写的完全不对还有80分运气也是真好. 其实挂了不止两个细节...以为是原题于是上来就写20分钟写完,然后过一会出一个锅... 然后看T2,感觉$O(nk^2)$也许差不多?常数很大...但也不会别的.挺好想但是不是很好写. 于是乎强烈谴责cbx没素质暴力水题考后还不改正解的无脸行径 于是就开始写,写了一个半小时. 看T3,绝对大神题

[考试反思]0122省选模拟12:延迟

博客咕过了一年我也就忘了我考试状态了2333. T1是弱智题但是没想...写个暴力跑路了(时间不够,主要投在T2/3上了) 然而其实想到了一个乱搞,觉得能得分的概率不大,结果数据奇水完全不对的玩意还有20分,然而我并没有写... 然而T2写的是正解,虽说没有其他人的状压优秀,T了一个细节WA了一个拿了80分,凑合吧. 然后T3时间不多的时候写的,拿个暴力,想到了正解大概怎么写但是没有写,太恶心. 考后改题写了写,一下午就过去了...一晚上也就过去了...弄得跟我颓废了半天一样... 然而是真xx

模拟测试68,69

68: 32 AlpaCa 41 03:08:20 31 02:46:16 30 02:46:28 102 03:08:20 69: 28 AlpaCa 20 02:51:15 60 03:05:32 0 01:39:45 80 03:05:32 彻底挂掉了呢. 不过也还好吧,至少之后的考试不会有那么大压力了吧(出第一机房是肯定的事了),那利用之后几场考试就调整好状态,下次再来嘛. 但是最近炸了那么多场还是要反思一下,其实不只是心态的问题,自身实力,考试技巧,时间分配等方面好像都有点问题. 69

微信在线信息模拟测试工具(基于Senparc.Weixin.MP)

目前为止似乎还没有看到过Web版的普通消息测试工具(除了官方针对高级接口的),现有的一些桌面版的几个测试工具也都是使用XML直接请求,非常不友好,我们来尝试做一个“面向对象”操作的测试工具. 测试工具在线DEMO:http://weixin.senparc.com/SimulateTool Senparc.Weixin.MP是一个开源的微信SDK项目,地址:https://github.com/JeffreySu/WeiXinMPSDK (其中https://github.com/Jeffrey