2018BNU校赛总决赛
题解是qls的题解我就懒得写了23333
A塞特斯玛斯塔
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
quailty是一名狂热的ACM音游选手，沉迷各种音乐游戏，比如Lunatic Rave 2，osu!之类的。
今天，quailty玩的是国内游戏厂商雷亚（并不是赞助商）出品的一款音乐游戏Cytus。
游戏中，玩家需要随着游戏界面中上下移动的扫描线来适时演奏对应音符。
当上下移动的黑色线（扫描线）与圆形的物体（音符）的圆心重合时点击音符。
普通音符（图中第一种）只需点击即可。
锁链音符（图中第二种）将带箭头的音符（滑块）按下后不要松开，并将滑块沿着斜线和圆点组成的路径拖动，直至拖动到最后一个圆点处方可松开。注意拖动过程中应保持滑块圆心始终与扫描线重合。
长按音符（图中第三种）按下后不要松开，原地不动，等扫描线到达其末端并显示判定结果后方可松开。
Cytus共有五种判定，从好到坏依次为：彩PERFECT、黑PERFECT、GOOD、BAD、MISS。
得分中包括了90%的“判定分”和10%的“连击分”，而连击分是累进计算的，断COMBO对其影响很大，往往只要有1个MISS就会损失几万的连击分。
彩PERFECT和黑PERFECT在计算得分时一视同仁，只要全部PERFECT即可获得满分，满分为1000000，被称为MILLION Master。
quailty真的很严格，如果打完一把没有拿到MILLION Master，他就认为自己是NAIVE Noob。
现在给你quailty打出的判定序列，请你输出这次游戏的评价是MILLION Master还是NAIVE Noob。
输入描述:
第一行是一个正整数T ( 1 ≤ T ≤ 5 )，表示测试数据的组数，
每组测试数据，第一行是一个正整数n ( 1 ≤ n ≤ 100000 )，表示该组测试数据包含的判定数。接下来的n行，每行包含"PERFECT"、"GOOD"、"BAD"、"MISS"之中的一个字符串，表示quailty打出的一个判定。
输出描述:
对于每组数据，输出一行，包含一个字符串，表示这次游戏的评价。
输入例子:
2
5
PERFECT
PERFECT
PERFECT
PERFECT
PERFECT
10
PERFECT
MISS
PERFECT
BAD
BAD
GOOD
BAD
GOOD
GOOD
MISS
输出例子:
MILLION Master
NAIVE Noob
-->
输入
2
5
PERFECT
PERFECT
PERFECT
PERFECT
PERFECT
10
PERFECT
MISS
PERFECT
BAD
BAD
GOOD
BAD
GOOD
GOOD
MISS
输出
MILLION Master
NAIVE Noob
判断是不是全是perfect。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=1e5+;
int n,m,flag,T;
char s[N],ans[]="PERFECT";
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
flag=;
for(int i=;i<=n;i++)
{
scanf("%s",s);
if(strcmp(s,ans)!=)
flag=;
}
if(flag)
printf("MILLION Master\n");
else
printf("NAIVE Noob\n");
}
return ;
}
B 外挂使用拒绝
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
ATG5是ATG系列最新作，游戏故事发生以美国洛杉矶及其周边地区为原型的城市Sos Lantos，是现实地区中的洛杉矶和南加州。制作单位拍摄了超过25万张相关照片，并且研究了人口调查和汽车销售数据，以建立游戏中的世界。
ATG系列历来都是以黑帮生活为背景的知名动作冒险游戏。主人公自然与黑道脱不了干系，在ATG5中游戏元素将会得到增强，加入了更加开放自由的世界，以故事驱动，以任务为准的游戏玩法和多人模式。故事主题聚焦金钱永不眠的南加利福尼亚。这次作品是有史以来最具活力的和最多元化的开放式世界，作为玩家可以反复进入三个角色的生活，玩交织在一起的所有内容。
ATG5这款游戏质量很高，但是外挂猖獗。。。
最近，三七开发现了一款神奇的外挂，可以让他在多个账号之间转移金钱。
神奇外挂的神奇不止于此，当他把一个账号的金钱转移到另一个账户时，原来账户里的金钱并不会减少！是不是很神奇？
三七开一共有n个账号，每一天他都会通过这个神奇外挂把第1个账号的金钱“转移”到第2个账号，再把第2个账号的金钱“转移”到第3个账号，……，再把第n-1个账号的金钱“转移”到第n个账号。
但是三七开忘了一件事情，游戏中金钱数量是有上限的，每当一个账号的金钱数大于等于1000000007(=109+7)时，这个账号的金钱数就会对109+7取模，即变成金钱数除以109+7的余数。尽管如此，三七开还是很开心地继续使用着他的神奇外挂，并且没有花账号里的一分金钱。
然而，在三七开使用了k天神奇外挂之后，B星公司（ATG5的发行公司）发现了他的开挂行为。B星公司对使用外挂行为非常仁慈，决定不对三七开进行封号处理，而是将三七开的所有账号的金钱数恢复至他开挂以前的数值。但服务器并没有关于那么久远的数据的存档，只有现在的金钱数的数据，以及检测到的开挂天数k。
你能帮助B星公司恢复三七开的账号数据吗？
输入描述:
第一行是一个正整数T(T ≤ 15)，表示测试数据的组数，
对于每组测试数据，
第一行包含两个整数n(2 ≤ n ≤ 1000),k(0 ≤ k ≤ 100000000)，表示账号个数和开挂天数，
第二行包含n个小于109+7的非负整数，第i个整数表示当前第i个账号的金钱数。
输出描述:
对于每组测试数据，输出一行，包含n个以空格分隔的非负整数（每个数范围小于10
9
+7，注意不要有行末空格），第i个整数表示开挂前第i个账号的金钱数。
输入例子:
2
3 1
3 2 1
4 2
1 2 1 2
输出例子:
3 1000000006 1000000006
1 0 1000000005 2
-->
输入
2
3 1
3 2 1
4 2
1 2 1 2
输出
3 1000000006 1000000006
1 0 1000000005 2
连加和连减这一类的都可以从杨辉三角找找规律2333，找找规律就能出通项了。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=1e3+;
LL a[N];
LL fac[N],inv[N];
LL ans[N],k;
int T,n,m,tk;
LL quickpow(LL x,LL n)
{
LL ans=;
x%=mod;
while(n)
{
if(n&) ans=ans*x%mod;
n>>=;
x=x*x%mod;
}
return ans;
}
void init(int n,LL k)
{
fac[]=;
LL p=;
for(int i=;i<=n && k>=;i++,k--)
fac[i]=fac[i-]*k%mod;
for(int i=;i<=n;i++)
p=p*i%mod;
inv[n]=quickpow(p,mod-);
for(int i=n-;i>=;i--)
inv[i]=inv[i+]*(i+)%mod;
return ;
}
LL comb(LL k,int n)
{
if(1LL*n>k)
return ;
else
return (fac[n]*inv[n])%mod;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%lld",&n,&k);
for(int i=;i<=n;i++)
scanf("%lld",a+i);
init(n,k);
clr(ans);
for(int i=;i<=n;i++)
{
tk=-;
m=-;
for(int j=i;j>=;j--)
{
tk++;
m=-m;
ans[i]=((ans[i]+comb(k,tk)*m%mod*a[j]%mod)%mod+mod)%mod;
}
}
for(int i=;i<n;i++)
printf("%lld ",ans[i]);
printf("%lld\n",ans[n]);
}
return ;
}
C 萌萌哒身高差
空间限制：C/C++ 32768K，其他语言65536K
Special Judge, 64bit IO Format: %lld
题目描述
“清明时节雨纷纷，路上行人欲断魂。”
然而wfy同学的心情是愉快的，因为BNU ACM队出去春游啦！并且，嗯。。。
以下是wfy同学的日记：
昨天，何老师告诉我们：明天我们去春游，大家准备好喝的和吃的哦！
大家听了都兴奋起来，有的欢呼，有的鼓掌，开心得不得了。第二天，我们早早地来到学校，迫不及待地上了车，来到了公园。一进门，啊，太美了！公园中有那么多树，有高有矮，有粗有瘦，密密的，在春风吹拂下轻轻摇摆着，像是欢迎我们的到来。公园中有那么多的鲜花，有红有黄，有紫有白，散发着淡淡的清香，闻得我们都醉了。公园的边角上有一条清澈的小河，河水缓缓地流淌着，可以看到水里的鱼儿在快活地游来游去，多自在啊！水草碧绿碧绿的，多新鲜啊！小河的旁边是一片小树林，远远望去一片鲜绿。我们在里面吃东西、做游戏、捉迷藏，玩得疯极了。树林的后面是连绵起伏的小山坡，蜿蜿的真像一条游动的蛇。当然，我觉得公园的天空也很美。它万里无云，一碧如洗，很清澈。小鸟在展翅飞翔，它们形态各异，一会儿上升，一会儿下滑，一会儿吃虫，一会儿在小树林里休息，非常悠闲。快乐时光总是那么短暂，很快，天色就昏暗了。我们依依不舍地上了车，回到了学校，我真希望明年的春天还能再来看看这美丽的公园。
回到学校后，何老师说：请大家排成一排，我们来拍照片啦！
何老师特别喜欢萌的东西，比如**，比如****，等等。
何老师认为，同学们站成一排时，相邻两个同学身高相差越多，这两个同学站在一起越萌。
那么所有相邻两个同学的身高差加起来越大，拍出来的照片就越萌，也就是这张照片的萌力指数。
何老师希望拍出来的照片的萌力指数尽可能大。
然而何老师并不是数学老师，而是语文老师。何老师觉得很GG。
何老师只想知道，如果让同学们随便站成一排(站成所有排列的可能性都相等)，萌力指数的数学期望是多少。
聪明的我一下子就算出了答案，然后何老师就奖励了我一个很萌的礼物。
今天真的好开心。
BNU ACM队共有n名同学，身高分别是，聪明的你能计算出何老师想要的数学期望吗？
输入描述:
第一个是一个正整数T(T ≤ 20)，表示测试数据的组数，
每组测试数据只有一行，包含一个整数n(2 ≤ n ≤ 100)。
输出描述:
对于每组测试数据，输出一行，包含一个实数，表示萌力指数的数学期望值，要求相对误差不超过，
也就是说，令输出结果为a，标准答案为b，若满足，则输出结果会被认为是正确答案。
输入例子:
2
2
3
输出例子:
1.000000000000
2.666666666667
-->
输入
2
2
3
输出
1.000000000000
2.666666666667
说明
对于第二组样例，所有可能的排列是[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]，所以答案是
嗯找找规律写个第四第五项就可以发觉是 $ \frac{n^2-1}{3} $ 。别去推了，我推了半天还推错了orz。赛后推出来了太麻烦，不如猜公式。就是从上一个n-1的排列去推加进去一个n以后增加了多少，那么f[n]=[n-1]+一个计算n加进去后期望增加的贡献。可以通过固定右端的数字然枚举左端的数字来算，然后还有左端没有以及右端没有总共三种情况。概率就相当于出现总数除总排列数。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=1e2+;
int T,n,m,all;
LL a[N],pre[N];
double ans[N];
void init(int n)
{
a[]=;
ans[]=;
for(int i=;i<=n;i++)
{
a[i]=a[i-]+;
pre[i]=pre[i-]+a[i];
ans[i]=1.0*pre[i]/;
}
return ;
}
int main()
{
init();
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
printf("%.10f\n",ans[n]);
}
return ;
}
D 雷电爆裂之力
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
输入描述:
第一行是一个正整数T(≤ 20)，表示测试数据的组数，
对于每组测试数据，
第一行是一个整数n,m,k(1≤ n,m,k ≤ 100000)，分别表示连接京师路与木铎路，木铎路与金声路，金声路与新街口外大街的道路个数，
第二行包含n个以空格分隔的整数a1,a2,...,an，表示连接京师路与木铎路的各个小道的南北方向坐标（单位：m），
第三行包含m个以空格分隔的整数b1,b2,...,bm，表示连接木铎路与金声路的各个小道的南北方向坐标（单位：m），
第四行包含k个以空格分隔的整数c1,c2,...,ck，表示连接金声路与新街口外大街的各个小道的南北方向坐标（单位：m），
保证每行坐标按严格递增的顺序给出，并且坐标绝对值不超过109。
输出描述:
对于每组测试数据，输出一行，包含一个整数，表示答案（单位：s）。
输入例子:
1
3 3 2
-1 1 4
-3 2 4
-1 1
输出例子:
5
-->
输入
1
3 3 2
-1 1 4
-3 2 4
-1 1
输出
5
序都给你排好了，你就枚举中间那条路的所有路位置，然后双指针指向前面和后面两边的路去做，O（n）的。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=1e5+;
int n,m,k;
LL a[N],b[N],c[N];
int T,lt,rt;
LL ans,pt;
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d%d",&n,&m,&k);
for(int i=;i<=n;i++)
scanf("%lld",a+i);
for(int i=;i<=m;i++)
scanf("%lld",b+i);
for(int i=;i<=k;i++)
scanf("%lld",c+i);
ans=abs(a[]-b[])+abs(b[]-c[]);
lt=rt=;
for(int i=;i<=m;i++)
{
while(lt<n && a[lt]<b[i])
lt++;
while(rt<k && c[rt]<b[i])
rt++;
pt=;
if(lt>)
pt+=min(abs(a[lt]-b[i]),abs(a[lt-]-b[i]));
else
pt+=abs(a[lt]-b[i]);
if(rt>)
pt+=min(abs(c[rt]-b[i]),abs(c[rt-]-b[i]));
else
pt+=abs(c[rt]-b[i]);
ans=min(ans,pt);
}
printf("%lld\n",ans+);
}
return ;
}
E 可以来拯救吗
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
quailty is BNU's red sun.
quailty非常喜欢给同学讲题，一天，他又拉着SK给他讲题。
quailty：给一个长为n的序列，求给定子序列的和，会吗？
SK：。。
quailty：给一个长为n的序列，求给定子序列的和的平方，会吗？
SK：。。。
quailty：给一个长为n的序列，求所有子序列的和的平方和，会吗？
SK：。。。。。
quailty：给一个长为n的序列，求所有长为k的子序列的和的平方和，会吗？
SK：。。。。。。。。
quailty：给一个长为n的序列，求所有长为k的子序列的和的平方的异或和，会...
SK：我^(^&*((^%^#……
SK拔出了他的40m长刀，场面就快控制不住了，请你赶快来做出这道题，拯救一下quailty。
quailty is BNU's red sun.
输入描述:
第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个正整数n,k(k ≤ n ≤ 100000)，分别表示序列长度和需要考虑的子序列长度，
接下来一行包含n个不超过1000的正整数，表示序列的n个元素，
为了简化问题，保证，也就是说，需要考虑的子序列不超过100000个。
输出描述:
对于每组测试数据，输出一行，包含一个整数，表示所有长为k的子序列的和的平方的异或和。
输入例子:
1
4 2
1 2 3 4
输出例子:
12
-->
输入
1
4 2
1 2 3 4
输出
12
说明
对于样例，长度为2的子序列有[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]，所以答案是9^16^25^25^36^49=12（这里'^'是C++中的异或运算符）。
dfs暴力枚举所有会出现的序列，因为他保证考虑的序列不超过$ 10^6 $个。同时n最长为1000，所以没事的能过。要注意的是一旦 $ k> \frac{a}{2} $ 那么我们考虑的序列应该是 $ n-k $ 的序列，然后拿总和减掉这个序列和就行了。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=1e5+;
LL a[N];
int n,k,T;
bool rev;
LL all,ans;
void dfs(int pt,int now,LL sum)
{
if(now==k)
{
if(rev) ans^=(all-sum)*(all-sum);
else ans^=sum*sum;
return ;
}
if(n-pt+<k-now) return ;
dfs(pt+,now,sum);
dfs(pt+,now+,sum+a[pt]);
return ;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&k);
all=;
rev=;
ans=;
for(int i=;i<=n;i++)
{
scanf("%lld",a+i);
all+=a[i];
}
if(k>n/)
{
rev=;
k=n-k;
}
dfs(,,);
printf("%lld\n",ans);
}
return ;
}
F 汤圆防漏理论
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
ghc很喜欢吃汤圆，但是汤圆很容易被粘(zhān)漏。
根据多年吃汤圆经验，ghc总结出了一套汤圆防漏理论：
互相接触的汤圆容易粘(zhān)在一起，并且接触面积不同，粘(zhān)在一起的粘(nián)度也不同。
当ghc要夹起一个汤圆时，这个汤圆和现在碗里与这个汤圆接触的所有汤圆之间的粘(nián)度的和，如果大于汤圆的硬度，这个汤圆就会被粘(zhān)漏。
今天ghc又要煮汤圆啦，今天要煮n个汤圆，并且摆盘的方法已经设计好：
汤圆按照编号，有m对汤圆互相接触，用xi, yi, zi表示编号为xi和yi的两个汤圆互相接触，粘(nián)度为zi。
汤圆当然是越软越好吃，但是ghc的厨艺只允许把所有汤圆煮成同样的硬度。那么，汤圆的硬度最小可以是多少，可以满足吃的过程中，存在一种夹汤圆的顺序，使得没有汤圆会被粘(zhān)漏呢？
注意：
不考虑汤圆的重力作用；
不能同时夹多个汤圆；
吃完汤圆一定要喝点汤。
输入描述:
第一行是一个正整数T(≤ 5)，表示测试数据的组数，
对于每组测试数据，
第一行是两个整数n,m(1≤ n,m≤ 100000)，
接下来m行，每行包含三个整数xi, yi, zi(1≤ xi, yi ≤ n, xi ≠ yi, 1 ≤ zi ≤ 1000000)，
同一对汤圆不会出现两次。
输出描述:
对于每组测试数据，输出一行，包含一个整数，表示汤圆硬度的最小值。
输入例子:
1
4 6
1 2 2
1 3 2
1 4 2
2 3 3
2 4 3
3 4 5
输出例子:
6
-->
输入
1
4 6
1 2 2
1 3 2
1 4 2
2 3 3
2 4 3
3 4 5
输出
6
嗯代码我又写挫了。就是每次都贪心的找连边的比边权和最小的删掉。为了这个过程我写了一个记录位置的小根堆然后动态的加入删除。但是记录和维护堆的代码写出来很长的。。然后q巨的做法直接用set一堆代码就省了。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=2e5+;
struct edg
{
int next,to,val;
}edge[N];
int head[N],etot;
void addedge(int u,int v,int val)
{
edge[++etot]=(edg){head[u],v,val};
head[u]=etot;
return ;
}
LL heap[N];
int hashed[N],too[N];
LL val[N],len,ans;
int htot,u,v,ve,n,m,T;
void init()
{
clr_1(head);
etot=htot=;
clr(val);
}
void add(LL x,int pt)
{
heap[++htot]=x;
hashed[htot]=pt;
too[hashed[htot]]=htot;
int p=htot;
while(p> && heap[p]<heap[p>>])
{
swap(too[hashed[p]],too[hashed[p>>]]);
swap(heap[p],heap[p>>]);
swap(hashed[p],hashed[p>>]);
p>>=;
}
return ;
}
void pop()
{
swap(too[hashed[]],too[hashed[htot]]);
swap(heap[],heap[htot]);
swap(hashed[],hashed[htot]);
htot--;
int p=,maxpt;
while(((p<<)<=htot && heap[p]>heap[p<<]) || ((p<<|)<=htot && heap[p]>heap[p<<|]))
{
if((p<<|)<=htot)
maxpt=heap[p<<]<heap[p<<|]?(p<<):(p<<|);
else
maxpt=(p<<);
swap(too[hashed[p]],too[hashed[maxpt]]);
swap(heap[p],heap[maxpt]);
swap(hashed[p],hashed[maxpt]);
p=maxpt;
}
return ;
}
void change(int p,LL now)
{
heap[p]=now;
while(p> && heap[p]<heap[p>>])
{
swap(too[hashed[p]],too[hashed[p>>]]);
swap(heap[p],heap[p>>]);
swap(hashed[p],hashed[p>>]);
p>>=;
}
return ;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
init();
for(int i=;i<=m;i++)
{
scanf("%d%d%d",&u,&v,&ve);
addedge(u,v,ve);
addedge(v,u,ve);
val[u]+=ve;
val[v]+=ve;
}
for(int i=;i<=n;i++)
add(val[i],i);
ans=heap[];
for(int i=;i<=n;i++)
{
u=hashed[];
len=heap[];
ans=max(ans,len);
pop();
for(int j=head[u];j!=-;j=edge[j].next)
{
v=edge[j].to;
if(too[v]<=htot)
{
val[v]-=edge[j].val;
change(too[v],val[v]);
}
}
}
printf("%lld\n",ans);
}
return ;
}
G 命名规范问题
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
驼峰命名法是起变量名的一种规范，大致来说是用混合的大小写字母来构成变量名，在这个问题里你可以假设具体规则如下：
1.每个变量名由至少2个单词拼接构成，且每个单词长度至少为2；
2.每个单词的首字母必须大写，其他位置必须小写（除了变量名的第一个单词允许全部小写外）。
但是SK同学的英语很差，看到长长的变量名就很难脑补出是由哪些单词组成的，因此看驼峰命名法的代码十分头疼。
还有一种下划线命名法，规则比较简单，即各个单词之间用下划线'_'连接，且字母全部小写。
现在给你一些变量名，你能将其中符合驼峰命名法规范的变量转换成下划线命名法吗？
输入描述:
第一行是一个正整数T(≤ 20000)，表示测试数据的组数，
每组测试数据只有一行，包含一个仅包含大小写英文字母且长度不超过20的变量名，
保证所有测试数据变量名长度总和不超过200000。
输出描述:
对于每组测试数据，输出一行，包含一个字符串，如果变量名符合驼峰命名法规范则将其改为下划线命名法，否则不变。
输入例子:
10
mystring
myString
String
SS
my
mySString
mString
STRING
StrinG
IndexOfString
输出例子:
mystring
my_string
String
SS
my
mySString
mString
STRING
StrinG
index_of_string
-->
输入
10
mystring
myString
String
SS
my
mySString
mString
STRING
StrinG
IndexOfString
输出
mystring
my_string
String
SS
my
mySString
mString
STRING
StrinG
index_of_string
简单码农题，你自己看着办。orz
标程正则20行。我代码怎么那么挫~
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=1e6+;
int T;
char s1[N],s2[N];
int tot,num,n;
bool flag;
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%s",s1);
tot=;
flag=;
num=;
n=strlen(s1);
for(int i=;s1[i];i++)
{
if(i> && (s1[i]>='A' && s1[i]<='Z') && (s1[i-]>='A' && s1[i-]<='Z'))
flag=;
if(s1[i]>='A' && s1[i]<='Z')
{
s2[tot++]='_';
s2[tot++]=s1[i]-'A'+'a';
num++;
}
else
s2[tot++]=s1[i];
}
s2[tot]='\0';
if(s1[]>='a' && s1[]<='z')
num++;
if(num< || (n>= &&(s1[]>='a' && s1[]<='z') && (s1[]>='A' && s1[]<='Z')) || (s1[n-]>='A' && s1[n-]<='Z') )
flag=;
if(flag)
printf("%s\n",s1);
else
printf("%s\n",(s1[]>='a' && s1[]<='z')?(s2):(s2+));
}
return ;
}
H 吾好梦中做题
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
SK同学最喜欢做梦了，因为梦里什么都有，甚至会有题目！
有一天，SK还真梦到了一个棘手的问题。
问题是这样的，在梦里出现了一个很长很长的只包含‘(’和‘)’的括号序列。按照梦里的指引，SK需要完成一些任务。任务分为两种：一是将某个给定位置的括号方向翻转一下，即原本是左括号则变为右括号，原本是右括号则变为左括号；二是询问以某个给定的位置为左端点的区间中最长的合法括号序列的长度。
合法括号序列是这样递归定义的：
1.()是合法括号序列；
2.如果A是合法的，那么(A)也是合法的；
3.如果A和B都合法，那么AB合法。
机智的SK在梦里瞬间解决了这些任务，但是他醒后却想不起来自己是如何做到的，于是请你来帮他回忆做法。
输入描述:
第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个正整数n(≤ 500000)和m(≤ 500000)，分别表示括号序列的长度以及任务个数，
第二行，一个只包含左右括号的字符串，表示初始的括号序列，
接下来m行，每行包含两个正整数x,y(1 ≤ x ≤ 2,1 ≤ y ≤ n)，分别表示任务种类以及给定的位置，
保证所有测试数据的括号序列长度之和与任务数之和均不超过500000。
输出描述:
对于每个任务二，输出一行，包含一个整数，表示以给定的位置为左端点的区间中最长的合法括号序列的长度，如果找不到合法括号序列则输出0。
输入例子:
1
7 5
()()())
2 2
2 1
1 2
2 3
2 1
输出例子:
0
6
4
0
-->
输入
1
7 5
()()())
2 2
2 1
1 2
2 3
2 1
输出
0
6
4
0
说明
对于第一个任务，以第二个括号为左端点的区间构成的序列有)、)(、)()、)()(、)()()和)()())，其中没有合法的括号序列，
对于第二个任务，以第一个括号为左端点的区间构成的序列有(、()、()(、()()、()()(、()()()和()()())，其中合法的括号序列为()、()()和()()()，长度最大值是6，
对于第三个任务，序列变为((()())，
对于第三个任务，以第三个括号为左端点的区间构成的序列有(、()、()(、()()和()())，其中合法的括号序列为()和()()，长度最大值是4，
对于第四个任务，以第一个括号为左端点的区间构成的序列有(、((、(((、((()、((()(、((()()和((()())，其中没有合法的括号序列。
我的写法差不多。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
#define ls(i) (i<<1)
#define rs(i) (i<<1|1)
#define mp make_pair
using namespace std;
const int N=5e5+;
int a[N],pre[N];
char s[N];
int T,n,m,q,op,x,t;
void init()
{
pre[]=;
return ;
}
struct node
{
int l,r,minx,tag;
}tree[N<<];
inline void add(int i,int y)
{
tree[i].tag+=y,tree[i].minx+=y;
return ;
}
inline void pushup(int i)
{
tree[i].minx=min(tree[ls(i)].minx,tree[rs(i)].minx);
return ;
}
inline void pushdown(int i)
{
if(tree[i].tag!=)
{
if(tree[i].l!=tree[i].r) add(ls(i),tree[i].tag),add(rs(i),tree[i].tag);
tree[i].tag=;
}
return ;
}
void init(int i,int l,int r)
{
tree[i]=(node){l,r};
if(l==r)
{
tree[i].minx=pre[l];
return;
}
int mid=(l+r)>>;
init(ls(i),l,mid);
init(rs(i),mid+,r);
pushup(i);
return ;
}
void update(int i,int l,int r,int x)
{
if(tree[i].l>=l && tree[i].r<=r)
{
add(i,x);
return ;
}
pushdown(i);
int mid=(tree[i].l+tree[i].r)>>;
if(l<=mid) update(ls(i),l,r,x);
if(r>mid) update(rs(i),l,r,x);
pushup(i);
return ;
}
int query(int i,int x)
{
if(tree[i].l==tree[i].r) return tree[i].minx;
pushdown(i);
int mid=(tree[i].l+tree[i].r)>>;
if(mid>=x) return query(ls(i),x);
else return query(rs(i),x);
}
int asklow(int i,int l,int r,int val)
{
if(tree[i].l>=l &&tree[i].r<=r)
{
if(tree[i].minx>=val) return n+;
if(tree[i].l==tree[i].r) return tree[i].l;
pushdown(i);
if(tree[ls(i)].minx<val) return asklow(ls(i),l,r,val);
else return asklow(rs(i),l,r,val);
}
pushdown(i);
int mid=(tree[i].l+tree[i].r)>>;
int ans=n+;
if(l<=mid) ans=min(asklow(ls(i),l,r,val),ans);
if(r>mid && ans==n+) ans=min(asklow(rs(i),l,r,val),ans);
return ans;
}
int askequ(int i,int l,int r,int val)
{
if(tree[i].l>=l &&tree[i].r<=r)
{
if(tree[i].minx>val) return -;
if(tree[i].l==tree[i].r) return tree[i].l;
pushdown(i);
if(tree[rs(i)].minx==val) return askequ(rs(i),l,r,val);
else return askequ(ls(i),l,r,val);
}
pushdown(i);
int mid=(tree[i].l+tree[i].r)>>;
int ans=-;
if(r>mid) ans=max(askequ(rs(i),l,r,val),ans);
if(l<=mid && ans==-) ans=max(askequ(ls(i),l,r,val),ans);
return ans;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&q);
scanf("%s",s);
init();
for(int i=;s[i];i++)
{
if(s[i]=='(')
{
a[i+]=;
pre[i+]=pre[i]+a[i+];
}
else
{
a[i+]=-;
pre[i+]=pre[i]+a[i+];
}
}
init(,,n);
for(int i=;i<=q;i++)
{
scanf("%d%d",&op,&x);
if(op==)
{
a[x]=-a[x];
update(,x,n,a[x]*);
}
else
{
t=x->?query(,x-):;
m=asklow(,x,n,t);
if(m!=n+)
printf("%d\n",m-x);
else
{
m=askequ(,x,n,t);
if(m!=-)
printf("%d\n",m-x+);
else
printf("0\n");
}
}
}
}
return ;
}
I 如何办好比赛
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
输入描述:
第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个正整数n(≤ 1000000)和k(≤ 1000000000)，分别表示队列长度和最终的比赛总期待度，
接下来一行包含n个字符，表示这个队列，第i个字符表示队列里的第i个人，'D'表示大佬，'M'表示萌新，保证不会出现其它字符。
输出描述:
对于每组测试数据，输出一行，包含一个整数，表示最少的交换次数，无解输出-1。
输入例子:
2
3 1
DMM
3 3
DMM
输出例子:
1
-1
-->
输入
2
3 1
DMM
3 3
DMM
输出
1
-1
你把大佬当做区间端点，你会发觉每个区间内萌新的期待度是相同的，就是前面的大佬的数量。然后一个交换操作就相当于把一个区间的萌新转移到相邻区间，对应的期待度也就是+1或-1。因此我们统计下当前期待度和要求期待度，他们的差就是要操作的最少次数。
如果要求期待度大于萌新数量*大佬数量，也就是萌新全部换到最右区间的情况，说明是无解的，输出-1。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define LL long long
#define INF 0x3f3f3f3f
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=3e6+;
int T,n,m,all;
LL ans,qdd;
char s[N];
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%lld",&n,&qdd);
scanf("%s",s);
m=;
ans=;
all=;
for(int i=;i<n;i++)
{
if(s[i]=='D')
++m;
else
ans+=1LL*m,all++;
}
if(qdd>1LL*all*m)
{
printf("-1\n");
continue;
}
if(qdd<ans) swap(qdd,ans);
printf("%lld\n",qdd-ans);
}
return ;
}
J 小白兔小灰兔
空间限制：C/C++ 32768K，其他语言65536K
Special Judge, 64bit IO Format: %lld
题目描述
老山羊伯伯在地里收白菜，小白兔和小灰兔看见了就一起来帮忙。
他们干了半天，终于干完了。
羊伯伯：小灰兔，这车白菜送给你！
小灰兔：谢谢羊伯伯！
羊伯伯：小白兔，我也送你一车白菜！
小白兔：我不要白菜！给我一包白菜种子吧！
羊伯伯：好！给你~
小白兔：谢谢羊伯伯~
小灰兔把白菜拉到家里之后，就跟大家梦想中的生活一样，躺着啥都不干，吃吃吃，吃了玩~（好想一辈子都这样啊~小灰兔心想。）
小白兔把种子拿回去，打算开始勤劳地种白菜。然而他发现不是所有土地都能用来种白菜，只有被阳光照到的地方可以种白菜。
小白兔生活的星球可以看作二维平面中的一个简单多边形，太阳可以看作一个点。小白兔想知道，这个星球上一共有长度多少的土地可以用来种白菜。
输入描述:
第一行是一个正整数T(≤ 20)，表示测试数据组数，
对于每组测试数据，
第一行是一个整数n(3≤ n≤ 10)，表示简单多边形的顶点数，
接下来n行，每行是两个整数xi,yi(-10≤ xi,yi≤10)，按照逆时针绕向给出简单多边形的n个顶点的坐标，
最后一行是两个整数x,y(-10≤ x,y≤10)，表示太阳的坐标，保证太阳在多边形外且不在多边形任意一条边所在直线上。
输出描述:
对于每组测试数据，输出一行，包含一个实数，表示可以用来种白菜的土地的总长度，要求相对误差不超过，
也就是说，令输出结果为a，标准答案为b，若满足，则输出结果会被认为是正确答案。
输入例子:
2
4
0 0
2 0
2 2
0 2
4 1
4
0 0
2 0
2 2
0 2
4 4
输出例子:
2.000000000000
4.000000000000
-->
输入
2
4
0 0
2 0
2 2
0 2
4 1
4
0 0
2 0
2 2
0 2
4 4
输出
2.000000000000
4.000000000000
嗯多边形是简单多边形的简称，也就是他可以是凹的，但他的边不能相交。了解这点就基本上知道做法了。如果是凸的就直接取中点和视点连线看有没有线段单点相交。有的话就是看不到的，没有就是看得到的。对于凹多边形则需要把每条边按照视点和各端点连线和他的交点对这条边进行切割，然后这些切割的小线段再去看中点与视点连线有没有和其他线段规范相交。有则小线段会被挡住。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
#define ls(i) (i<<1)
#define rs(i) (i<<1|1)
#define mp make_pair
using namespace std;
typedef double db;
const int N=5e5+;
const db eps=1e-;
int equzero(db t)//带精度大小判断
{
if(t>eps) return ;
if(t<-eps) return -;
return ;
}
struct Point
{
db x,y;
Point(){}
Point(db _x,db _y):x(_x),y(_y) {}
Point operator +(const Point &b) const //+
{
return Point(x+b.x,y+b.y);
}
Point operator -(const Point &b) const//-
{
return Point(x-b.x,y-b.y);
}
Point operator *(const db &b) const// 放大
{
return Point(x*b,y*b);
}
Point operator /(const db &b) const//缩小
{
return Point (x/b,y/b);
}
db dot(const Point &b) const//点积
{
return x*b.x+y*b.y;
}
db det(const Point &b) const//叉积
{
return x*b.y-b.x*y;
}
bool operator ==(const Point &b) const
{
return equzero(x-b.x)== && equzero(y-b.y)==;
}
bool operator !=(const Point &b) const
{
return !(Point(x,y)==b);
}
db mo() //模
{
return sqrt(x*x+y*y);
}
}pt[N],u,v,mid;
struct Line
{
Point a,b;
Line (){}
Line (Point _a,Point _b):a(_a),b(_b) {};
bool quickrej(const Line &t) const//快速排斥判断
{
return equzero(min(a.x,b.x)-max(t.a.x,t.b.x))<= && equzero(min(t.a.x,t.b.x)-max(a.x,b.x))<= && equzero(min(a.y,b.y)-max(t.a.y,t.b.y))<= && equzero(min(t.a.y,t.b.y)-max(a.y,b.y))<=;
}
db len() const
{
return (b-a).mo();
}
bool stra(const Line &t) const //跨立判断
{
return equzero((a-t.a).det(t.b-t.a)*(b-t.a).det(t.b-t.a))< && equzero((t.a-a).det(b-a)*(t.b-a).det(b-a))< ;
}
bool gfxj(const Line &t) const //规范相交
{
return quickrej(t) && stra(t);
}
bool on(const Point &t) const //点在线段上
{
Line p=Line(a,b);
if(p.a.x>p.b.x)
swap(p.a,p.b);
if(equzero(t.x-p.a.x)< || equzero(t.x-p.b.x)>)
return false;
if(equzero((p.a-t).det(p.b-t))==)
return true;
else
return false;
}
bool kddxj(const Line &t) const //可多点相交
{
return quickrej(t) && (stra(t) || on(t.a) || on(t.b) || t.on(a) || t.on(b));
}
bool para(const Line &t) const // 平行或在一条直线上
{
return equzero((a.y-b.y)*(t.a.x-t.b.x)-(t.a.y-t.b.y)*(a.x-b.x))== ;
}
db operator & (const Line &t) const //返回切点占直线比例,距a比例
{
if(equzero((a-b).det(t.a-t.b))==)return -INF;
db tk=((a-t.a).det(t.a-t.b))/((a-b).det(t.a-t.b));
return equzero(tk)>= && equzero(tk-)<= ? tk : -INF;
}
}le[N],lu,lv;
int n,m,T;
vector<db> cp;
db ans,ins,rate;
bool flag;
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(int i=;i<=n;i++)
scanf("%lf%lf",&pt[i].x,&pt[i].y);
for(int i=;i<n;i++)
le[i]=Line(pt[i],pt[(i+)%n]);
ans=;
for(int i=;i<n;i++)
{
cp.clear();
for(int j=;j<n;j++)
{
ins=le[i]&Line(pt[n],pt[j]);
if(ins>=-) cp.pb(ins);
}
sort(cp.begin(),cp.end());
rate=;
for(int j=;j<cp.size()-;j++)
{
lu=Line(pt[n],le[i].a+(le[i].b-le[i].a)*((cp[j]+cp[j+])/));
flag=;
for(int k=;k<n;k++)
{
if(lu.gfxj(le[k]))
{
flag=;
break;
}
}
if(!flag)
{
rate+=cp[j+]-cp[j];
}
}
ans+=rate*le[i].len();
}
printf("%.12f\n",ans);
}
return ;
}
K 好学期来临吧
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld
题目描述
“只有投入才能获得真正的快乐” —— 鲁迅
SK同学这学期非常忙绿，他刚刚安排好n项工作的进行顺序，就发现BOSS又给了他m项工作，他只好想办法将这m项工作穿插到原来的n项工作之间进行（不改变原来n项工作的相对顺序）。
SK同学如果投入到某项工作中，就会收获一些快乐。之前有n项工作，现在又多了m项工作，本来，应该收获双倍的快乐，但是，SK同学发现自己不能连续投入到两个相邻的工作中。
SK同学想收获尽可能多的快乐，只好请熟练的你来帮助他了~
输入描述:
第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个正整数n(≤ 1000)和m(≤ 100)，分别表示原来安排好的n项工作和新增的m项工作，
接下来一行包含n个正整数，表示前n项工作投入时收获的快乐值，
接下来一行包含m个正整数，表示新增的m项工作投入时收获的快乐值，
所有快乐值都不超过100000。
输出描述:
对于每组测试数据，输出一行，包含一个整数，表示能收获的快乐值之和的最大值。
输入例子:
2
2 2
2 2
1 1
3 2
8 2 7
1 5
输出例子:
4
20
-->
输入
2
2 2
2 2
1 1
3 2
8 2 7
1 5
输出
4
20
说明
对于第一组样例，可以将工作安排成[2,1,2,1],[1,2,1,2],[2,1,1,2]三种方案之一，然后选出2+2来投入。
对于第二组样例，可以将工作安排成[8,2,7,1,5],[8,1,5,2,7],[5,1,8,2,7],[8,2,5,1,7]五种方案之一，然后选出8+7+5来投入。
对应四种状态：0：选择前n个工作，最后一个（第i个）不投入 ；1：选择前n个工作，最后一个（第i个）不投入 ；2：选择后m个工作，不投入，也就是选择j；选择后m个工作，投入，也就是选择k。
#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define mod 1000000007
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
#define ls(i) (i<<1)
#define rs(i) (i<<1|1)
#define mp make_pair
using namespace std;
typedef double db;
const int N=1e3+;
const int M=1e2+;
int a[N],b[M];
int dp[][M][M][];
int n,m,T,ans;
int main()
{
scanf("%d",&T);
while(T--)
{
clr(dp);
scanf("%d",&n);
scanf("%d",&m);
for(int i=;i<=n;i++)
scanf("%d",a+i);
for(int i=;i<=m;i++)
scanf("%d",b+i);
sort(b+,b+m+);
ans=;
for(int i=;i<=n;i++)
for(int j=;j<=m;j++)
for(int k=m;k>=j-;k--)
{
if(i>)
{
dp[i&][j][k][]=max(max(dp[i&^][j][k][],dp[i&^][j][k][]),max(dp[i&^][j][k][],dp[i&^][j][k][]));
dp[i&][j][k][]=max(dp[i&^][j][k][],dp[i&^][j][k][])+a[i];
}
if(j>) dp[i&][j][k][]=max(max(dp[i&][j-][k][],dp[i&][j-][k][]),max(dp[i&][j-][k][],dp[i&][j-][k][]));
if(k<m) dp[i&][j][k][]=max(dp[i&][j][k+][],dp[i&][j][k+][])+b[k+];
}
for(int i=;i<=m;i++)
ans=max(max(max(dp[n&][i][i-][],dp[n&][i][i-][]),max(dp[n&][i][i-][],dp[n&][i][i-][])),ans);
printf("%d\n",ans);
}
return ;
}
| K | 好学期来临吧 |
2018BNU校赛总决赛的更多相关文章
- BNU校赛总决赛J 小白兔小灰兔 相交计算几何模板
J 小白兔小灰兔 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32768K,其他语言65536K Special Judge, 64bit IO Format: %lld 题目描述 ...
- 2016 华南师大ACM校赛 SCNUCPC 非官方题解
我要举报本次校赛出题人的消极出题!!! 官方题解请戳:http://3.scnuacm2015.sinaapp.com/?p=89(其实就是一堆代码没有题解) A. 树链剖分数据结构板题 题目大意:我 ...
- SCNU省选校赛第二场B题题解
今晚的校赛又告一段落啦,终于"开斋"了! AC了两题,还算是满意的,英语还是硬伤. 来看题目吧! B. Array time limit per test 2 seconds me ...
- 2014上半年acm总结（1）（入门+校赛）
大一下学期才开始了acm,不得不说有一点迟,但是acm确实使我的生活充实了很多,,不至于像以前一样经常没事干= = 上学期的颓废使我的c语言学的渣的一笔..靠考前突击才基本掌握了语法 寒假突然醒悟, ...
- 2017CUIT校赛-线上赛
2017Pwnhub杯-CUIT校赛 这是CUIT第十三届校赛啦,也是我参加的第一次校赛. 在被虐到崩溃的过程中也学到了一些东西. 这次比赛是从5.27早上十点打到5.28晚上十点,共36小时,中间睡 ...
- HZNU第十二届校赛赛后补题
愉快的校赛翻皮水! 题解 A 温暖的签到,注意用gets #include <map> #include <set> #include <ctime> #inclu ...
- 校赛F
问题描述 例如对于数列[1 2 3 4 5 6],排序后变为[6 1 5 2 4 3].换句话说,对于一个有序递增的序列a1, a2, a3, ……, an,排序后为an, a1, an-1, a2, ...
- PKU2018校赛 H题 Safe Upper Bound
http://poj.openjudge.cn/practice/C18H 题目 算平均数用到公式\[\bar{x}=\frac{x_1+x_2+x_3+\cdots+x_n}{n}\] 但如果用in ...
- 【魔改】hdu6325 多校赛3G xy排序凸包+llvector模板
凸包算法前的预处理,可以极角排序,也可以按X,Y轴排序, 极角排序需要找到角落里的一个点,Xy轴排序要跑两遍凸包 而本题的要求只要一个上半凸包,并且有X轴从小到大以及字典序限制,完全符合xy排序,直接 ...
随机推荐
- iframe子夜页面调父页面的方法 取父页面的值
1.调父页面的方法的写法 window.parent.yincang();//yincang()是父页面的一个方法 2.取父页面的值的写法 window.parent.document.gettEle ...
- laravel 重定向路由带参数
转载: http://www.cnblogs.com/foreversun/p/5642176.html 举例: 路由: //任务列表页 $router->get('/taskDetail/{i ...
- 【leetcode 简单】第三十四题 只出现一次的数字
给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次.找出那个只出现了一次的元素. 说明: 你的算法应该具有线性时间复杂度. 你可以不使用额外空间来实现吗? 示例 1: 输入: [ ...
- C# 操作资源文件
(1)首先引用这两个命名空间 (2)两种方式调用资源文件中的内容 private void button2_Click(object sender, EventArgs e) { //通过Resour ...
- python作业购物车（第二周）
一.作业需求: 1.启动程序后,输入用户名密码后,如果是第一次登录,让用户输入工资,然后打印商品列表 2.允许用户根据商品编号购买商品 3.用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒 4 ...
- Fiddler 抓包工具总结(转)
阅读目录 1. Fiddler 抓包简介 1). 字段说明 2). Statistics 请求的性能数据分析 3). Inspectors 查看数据内容 4). AutoResponder 允许拦截制 ...
- slave->pxc后GTID不一致
以下两个参数在两个节点是对得上的. | wsrep_last_applied | 3363764 | | wsrep_last_committed | 3363764 但show master sta ...
- MySQL Warning: Using a password on the command line interface can be insecure.解决办法
转自 http://www.cnblogs.com/sunss/p/6256706.html 被一个小朋友问到,直接公布答案: If your MySQL client/server version ...
- Codeforces Round #434 (Div. 2)
Codeforces Round #434 (Div. 2) 刚好时间对得上,就去打了一场cf,发现自己的代码正确度有待提高. A. k-rounding 题目描述:给定两个整数\(n, k\),求一 ...
- 多播知识by 陈胜君
简单的讲一下多拨的说明:一.多拨分物理多拨和虚拟多拨. 物理多拨是电信老套餐,就是一个宽带支持四个内网设备同时拨号上网,即2004年以前,允许家里四台电脑直接连LAN网口启动拨号,同时允许四拨在线.现 ...