CSP2024-S GD 迷惑行为大赏：中文字符
前一部分是 gbk，后一部分是 utf-8
共 311K
使用 grep -P '[\x{0100}-\x{ffff}]+' -anR --color=never answers 寻找，然后通过 VSCode 转换两次编码并合并得到。文件太大了，乱码行就不删除了啊。
answers/GD-S00735/detect/detect.cpp:15:void solve(){//变量名很多，不要写错
answers/GD-S00860/detect/detect.cpp:62: // 瓒呴€熶綅绉诲尯闂达紝鍙岀鍧囬棴
answers/GD-S00860/detect/detect.cpp:103: // 璁＄畻閫熷害
answers/GD-S00860/arena/arena.cpp:89: // 鍓╀綑姣旇禌杞暟
answers/GD-S00860/arena/arena.cpp:91: // 鍓╀綑浜烘暟
answers/GD-S00860/arena/arena.cpp:97: // 妯℃嫙姣旇禌
answers/GD-S00860/arena/arena.cpp:107: // 鍚庤€呬负鎿備富
answers/GD-S00860/arena/arena.cpp:115: // 鍓嶈€呬负鎿備富
answers/GD-S01557/detect/detect.cpp:8:int tect[100010];//监控位置
answers/GD-S01557/detect/detect.cpp:9:double v[100010];//汽车速度
answers/GD-S01557/detect/detect.cpp:10:bool isv[100010],iss[100010];//是否超速、是否停止
answers/GD-S00383/color/color.cpp:37:鸟为什么会飞？
answers/GD-S00383/color/color.cpp:38:因为它们向往飞向天空？
answers/GD-S00383/color/color.cpp:39:不然
answers/GD-S00383/color/color.cpp:40:那么...你的答案？
answers/GD-S00383/color/color.cpp:41:因为它们必须飞向天空
answers/GD-S00383/color/color.cpp:42:当终焉的陨星终究落下
answers/GD-S00383/color/color.cpp:43:唯有飞翔的鸟儿
answers/GD-S00383/color/color.cpp:44:才能获得自由的生命
answers/GD-S00383/arena/arena.cpp:42:www好逆天 t1很简单A了吧，t2t3t4什么鬼啊！！！！！！
answers/GD-S00383/arena/arena.cpp:43:感觉上午的内容有点颠
answers/GD-S00383/arena/arena.cpp:46:游戏怎么可能比老婆重要呢？
answers/GD-S00383/arena/arena.cpp:48:“我有什么可以喜欢的”
answers/GD-S00383/arena/arena.cpp:49:回答依旧，只有一句
answers/GD-S00383/arena/arena.cpp:50:我喜欢你
answers/GD-S00383/arena/arena.cpp:51:只需要这句就够了
answers/GD-S00383/arena/arena.cpp:52:无论你多美，成绩多好，我们聊了多少，都不是最重要的
answers/GD-S00383/arena/arena.cpp:53:重要的是，我只喜欢你
answers/GD-S00383/arena/arena.cpp:55:——一生太长，墓志铭太短
answers/GD-S00383/arena/arena.cpp:56:这句话的背后，是奥托500年对爱的执着
answers/GD-S00383/arena/arena.cpp:57:你常说，活着
answers/GD-S00383/arena/arena.cpp:58:他对卡莲说的最后一句话，亦是
answers/GD-S00383/arena/arena.cpp:59:“活下去”
answers/GD-S01518/color/color.cpp:11: //优化
answers/GD-S01518/color/color.cpp:32: //优化
answers/GD-S03370/detect/detect.cpp:91: int pos = lower_bound(p+1, p+m+1, st)-p; // 获得最近测速器的编号
answers/GD-S03370/duel/duel.cpp:12: sort(po+1, po+n+1); // 排序分块
answers/GD-S03370/color/color.cpp:16: color[now] = 1; // 涂成红色
answers/GD-S01366/detect/detect.cpp:22: for(int i=tot;i>=1;i--){//右边有没有r<=它的
answers/GD-S01366/detect/detect.cpp:47: while(ub-lb>1){//最后一个会超速的地方
answers/GD-S01366/detect/detect.cpp:56: while(ub-lb>1){//第一个会超速的地方
answers/GD-S01217/detect/detect.cpp:32: //距离在其前且离其最近的测速仪
answers/GD-S01217/detect/detect.cpp:38: ++mx; // 从 x 开始往后的点都要 + 1
answers/GD-S01217/detect/detect.cpp:78: ++mx;//从这个点开始超速
answers/GD-S02952/detect/detect.cpp:6://q指第i台机器可以测多少车超速
answers/GD-S02952/detect/detect.cpp:7://r指第i台机器测了哪些车超速
answers/GD-S02952/detect/detect.cpp:8://s指第i台车会被哪些机器记超速
answers/GD-S00437/detect/detect.cpp:21: //找l,r区间内第一个满足s[i] + car[i].a * p[j] > 0的
answers/GD-S00437/detect/detect.cpp:22: while(l < r)//二分查找答案
answers/GD-S00437/detect/detect.cpp:34: //找l,r区间内第一个满足 s[i] + car[i].a * p[j] > 0的
answers/GD-S00437/detect/detect.cpp:40: if(s[i] + car[i].a * p[mid] > 0)//如果当前点可行的话
answers/GD-S00437/detect/detect.cpp:91: //查找左端点
answers/GD-S00437/detect/detect.cpp:94: //单调递减
answers/GD-S00437/detect/detect.cpp:95: else if(s[i] + car[i].a * p[head] > 0)seg[i].first = head; //只能是第一个
answers/GD-S00437/detect/detect.cpp:96: else continue;//没有能检查到的区间
answers/GD-S00437/detect/detect.cpp:98: //查找右端点
answers/GD-S00437/detect/detect.cpp:112: int l = 1, r = 1; //已经处理到多少条线段
answers/GD-S00437/detect/detect.cpp:113: int las = 0;//上一次选取的位置
answers/GD-S00437/detect/detect.cpp:122: if(bucket[i] > las) //有删除边
answers/GD-S00062/detect/detect.cpp:117: L++;//记得加 1
answers/GD-S00062/color/color.cpp:120: void slv() {//离散化
answers/GD-S00062/color/color.cpp:127: //找到前面和后面的最大值，以及 a[i - 1]
answers/GD-S00062/color/color.cpp:138: //剩下的区间加上 a[i] == a[i - 1]
answers/GD-S00062/color/color.cpp:179: void slv() {//离散化
answers/GD-S00062/color/color.cpp:188: //找到前面和后面的最大值，以及 a[i - 1]
answers/GD-S00062/color/color.cpp:204: //剩下的区间加上 a[i] == a[i - 1]
answers/GD-S00039/detect/detect.cpp:100:当一辆车的初速度为v0加速度a则当行驶路程为s时，
answers/GD-S00039/duel/duel.cpp:33:让剩下的怪物尽量少。
answers/GD-S00039/duel/duel.cpp:34:让每一个怪物发挥最大的价值
answers/GD-S00039/duel/duel.cpp:35:让每一个怪物用尽攻击他人的数量1
answers/GD-S00039/arena/arena.cpp:73:00:00 哇这键盘怎么切换不了中英文啊
answers/GD-S02803/detect/detect.cpp:10: int l, r; // [l,r] 之间必须有一个
answers/GD-S02803/detect/detect.cpp:13:bool check(int d, int x, int y, int i){ // d 初始位置，x 初始速度，y 加速度
answers/GD-S02803/detect/detect.cpp:14: d = p[i] - d; // 必须要让 d > 0
answers/GD-S02194/detect/detect.cpp:11:map<int,map<int,int> > mp; //第mi辆车,在道路m2位置超时则m3==1
answers/GD-S03263/detect/detect.cpp:4:int ODcar=0;//超速车
answers/GD-S03263/detect/detect.cpp:5:int ClCam=0;//可关闭摄像头数
answers/GD-S03263/detect/detect.cpp:12: int Decnum;//能检测到超速的摄像头的数量
answers/GD-S03263/detect/detect.cpp:13: int tctr[10005];//能检测到超速的摄像头在dtec中的下标
answers/GD-S03263/detect/detect.cpp:16:overDriveWindow odws[10005];//天呐是10005*(2*sizeof(double)+10006*sizeof(int)的结构体数组我们没救了!
answers/GD-S03263/detect/detect.cpp:18:bool mkdtec[100005];//标记对结果没有影响的摄像头
answers/GD-S03263/detect/detect.cpp:19:overDriveWindow cntOdw(car cr){//计算超速区间
answers/GD-S03263/detect/detect.cpp:23: double t=(V-cr.v)/cr.a;//从v0变为V的时间
answers/GD-S03263/detect/detect.cpp:24: if(cr.v>V){//初速度超速
answers/GD-S03263/detect/detect.cpp:25: if(vt>V){//末速度超速
answers/GD-S03263/detect/detect.cpp:26: //全程超速
answers/GD-S03263/detect/detect.cpp:30: else{//末速度不超速
answers/GD-S03263/detect/detect.cpp:31: //先超后不超
answers/GD-S03263/detect/detect.cpp:36: else{//初速度不超速
answers/GD-S03263/detect/detect.cpp:37: if(vt>V){//末速度超速
answers/GD-S03263/detect/detect.cpp:41: else{//末速度不超速
answers/GD-S03263/detect/detect.cpp:42: //全程不超速
answers/GD-S03263/detect/detect.cpp:49:void FindMinCam(int curCam){//被忽略的摄像头
answers/GD-S03263/detect/detect.cpp:89: ODcar=0;//超速车
answers/GD-S03263/detect/detect.cpp:90: ClCam=INT_MIN;//可关闭摄像头数
answers/GD-S03263/detect/detect.cpp:96: //计算每辆车的超速区间
answers/GD-S03263/detect/detect.cpp:99: //统计每个超速区间涉及到摄像头
answers/GD-S03263/detect/detect.cpp:110: printf("%d ",ODcar);//抢先输出答案然而没有卵用！
answers/GD-S03263/detect/detect.cpp:114: FindMinCam(i);//使用m^m的超低效率dfs寻找最多可以去除的摄像头数！
answers/GD-S02722/detect/detect.cpp:25: //开始监测-第一轮
answers/GD-S02722/detect/detect.cpp:33: //加速度越来越大时
answers/GD-S02722/detect/detect.cpp:46: //加速度越来越小时
answers/GD-S02722/detect/detect.cpp:55: //验证位置
answers/GD-S02828/detect/detect.cpp:40: }//找第一个测速
answers/GD-S02828/detect/detect.cpp:56: if(tt<0)//根号内不得为零
answers/GD-S02828/detect/detect.cpp:64: } //第一个测速超速，找最后一个超速位置
answers/GD-S02828/detect/detect.cpp:73: if(v>V){//超速，找起始位
answers/GD-S02828/detect/detect.cpp:94: if(tt<=V)//最后一个测速点也不超速，跳过
answers/GD-S02828/detect/detect.cpp:98: while(l<r){//找起始位
answers/GD-S03411/detect/detect.cpp:10:bool testfind[N];//测速删除
answers/GD-S02999/detect/detect.cpp:10:bool ve[100005];//是否超速
answers/GD-S02999/detect/detect.cpp:11:bool use[100005];//camera是否使用
answers/GD-S02999/detect/detect.cpp:33: if(c[i].a) {//匀加速
answers/GD-S02999/detect/detect.cpp:35:// /*DEBUG*/printf("第%d辆车在经过第%d个测速仪时未超速,此时第%d车的速度为0\n",i,j,i);
answers/GD-S02999/detect/detect.cpp:43:// /*DEBUG*/printf("第%d辆车在经过第%d个测速仪时超速,此时第%d车的瞬时速度为%.5lf(sqrt(pow(%d,2)+2*%d*(%d-%d)))\n",i,j,i,vnow,c[i].v,c[i].a,p[j],c[i].d);
answers/GD-S02999/detect/detect.cpp:46:// printf("第%d辆车在经过第%d个测速仪时未超速,此时第%d车的瞬时速度为%.5lf(sqrt(pow(%d,2)+2*%d*(%d-%d)))\n",i,j,i,vnow,c[i].v,c[i].a,p[j],c[i].d);
answers/GD-S02999/detect/detect.cpp:55:// /*DEBUG*/printf("第%d辆车在经过第%d个测速仪时超速,此时第%d车的速度为%d\n",i,j,i,c[i].v);
answers/GD-S02999/detect/detect.cpp:58:// printf("第%d辆车在经过第%d个测速仪时未超速,此时第%d车的瞬时速度为%d\n",i,j,i,c[i].v);
answers/GD-S02999/detect/detect.cpp:87: if(tmp.size()==s.size()) {//可以关掉
answers/GD-S02999/color/color.cpp:5:void func(int cnt,bool c,int sum) {//cnt:当前位置;c:当前颜色(color[cnt]);sum:当前总和
answers/GD-S02337/duel/duel.cpp:3:long long n,ans=0;//ans代表目前还活着的
answers/GD-S01644/color/color.cpp:63: bool _c = true,c1 = true;//涓寸晫鐐圭殑棰滆壊
answers/GD-S00995/duel/duel.cpp:6: bool d=true;//是否在游戏中
answers/GD-S00995/duel/duel.cpp:7: bool h=true;//能否攻击
answers/GD-S03135/detect/detect.cpp:6: double ve,ol,os,oe; //ol超速距离，os/oe超速起始/离开道路位置
answers/GD-S00178/duel/duel.cpp:2: 贪心，即能kill就kill
answers/GD-S00178/duel/duel.cpp:3: 先排序一遍，双指针从最小往上减，最后遍历一遍桶，查看存活数
answers/GD-S00178/duel/duel.cpp:4: n大小至1e5，由于r数值较小，为防万一，考虑桶排序
answers/GD-S00178/color/color.cpp:7:int a[maxn],b[maxn],ans;//0代表红色，1代表蓝色
answers/GD-S00644/arena/arena.cpp:83:// 难道不是死局吗？
answers/GD-S03176/detect/detect.cpp:10: int x,y,z;//x 驶入位置 y 初速度 z 加速度
answers/GD-S03140/detect/detect.cpp:30: if(start>=roadlong){//路段不超速
answers/GD-S03140/detect/detect.cpp:34: else{//路段超速
answers/GD-S03140/detect/detect.cpp:40: if(v>maxv){//一直超速
answers/GD-S03140/detect/detect.cpp:44: else{//一直不超速
answers/GD-S03140/detect/detect.cpp:60: //完成车辆输入及计算
answers/GD-S03140/detect/detect.cpp:67: if(tests[j].d>=cars[i].from && tests[j].d<=cars[i].to){//判定超速
answers/GD-S03140/detect/detect.cpp:75: for(int i=0;i<testnum;i++){//遍历测速器查看可删除数量
answers/GD-S03140/duel/duel.cpp:10:vector<int> input2(incount,0);//初始化数组
answers/GD-S03140/duel/duel.cpp:16:for(int i=1;i<incount;i++){//i:移位数
answers/GD-S03140/duel/duel.cpp:17: if(input1[i]>input2[0])//找到第一个错开的数字,input1移位
answers/GD-S03140/duel/duel.cpp:20: for(int j=0;j<incount-i;j++)//计算击败个数(遍历
answers/GD-S01341/detect/detect.cpp:6:}q[N+5];//会被判定为超速的区间
answers/GD-S01341/detect/detect.cpp:64: s=(V*V-v[i]*v[i])/2.0/a[i];//刚好加速到限速时，行驶的距离
answers/GD-S01341/detect/detect.cpp:67: else q[i].l=-1; //如果l>=L，说明全程不超速
answers/GD-S01341/detect/detect.cpp:73: s=(V*V-v[i]*v[i])/2.0/a[i];//刚好减速到限速时，行驶的距离
answers/GD-S01341/detect/detect.cpp:75: if(r>L) q[i].l=d[i],q[i].r=L;//走完了还没减下来，全程超速
answers/GD-S00737/detect/detect.cpp:9:int d[O],w[O];//驶离位置
answers/GD-S00737/detect/detect.cpp:10:int l[O],r[O];//表示该车违章区间
answers/GD-S00737/detect/detect.cpp:21:int ygx(){//在dt个区间[ll,rr]内找dt个数，求去重后最小长度
answers/GD-S03529/arena/arena.cpp:17:// 左子树擂主：如果左边可能不可以那么右子树全体可以，下界变成 0
answers/GD-S03529/arena/arena.cpp:18:// 右子树擂主：右子树全体可以，进左子树 ok
answers/GD-S03529/arena/arena.cpp:20:// 左子树擂主：如果左边稳了那么右边全不可以，否则左边全不可以右边可以 ok
answers/GD-S03529/arena/arena.cpp:21:// 右子树擂主：如果右边可能不可以那么左子树可以，下界变成左子树和右边>d 最小值
answers/GD-S00542/duel/duel.cpp:15: cout << n / 2 << endl; // 试图骗分.jpg
answers/GD-S03250/arena/arena.cpp:19://为什么没有水??
answers/GD-S02218/detect/detect.cpp:36: if(v[i]<=V&&a[i]>0){//加速车
answers/GD-S02218/detect/detect.cpp:44: if(v[i]>V&&a[i]<0){//减速车
answers/GD-S02218/duel/duel.cpp:12: //cnt当前这个数的个数
answers/GD-S02218/duel/duel.cpp:13: //now在这个数前有多少个小于它的
answers/GD-S02218/duel/duel.cpp:14: //del已经删了多少数
answers/GD-S00561/detect/detect.cpp:16:int main()//特判+暴力 预期得分60
answers/GD-S00561/color/color.cpp:22:void aa(bool x[100005],int y)//完啦，真暴力来哩 。O(T 2^n n^3/2)
answers/GD-S00317/duel/duel.cpp:42: if(cnt_1+cnt_2==n){//只有1和2(5~10
answers/GD-S00317/duel/duel.cpp:44: else cout<<cnt_1;//剩下cnt_1-cnt_2(能被2退出的1)+cnt_2(2不会退出)=cnt_1
answers/GD-S02545/arena/arena.cpp:44: if(x&1)//右儿子
answers/GD-S03108/detect/detect.cpp:47: zk = (v[i] == mv);//速度相等，则出发之后才超速
answers/GD-S03108/detect/detect.cpp:49: else if(d[i] + ((mv * mv - v[i] * v[i]) + 2 * a[i] - 1) / (2 * a[i]) >= len){//结尾之后才超速
answers/GD-S03108/detect/detect.cpp:53: ls = d[i] + ((mv * mv - v[i] * v[i]) + 2 * a[i] - 1) / (2 * a[i]);//此区间左开，所以可以向上取整，如果有取整就要闭合
answers/GD-S03108/detect/detect.cpp:66: if(d[i] + (mv * mv - v[i] * v[i]) / (2 * a[i]) >= len){//右开，向下取整；全程超速
answers/GD-S03108/detect/detect.cpp:69: else{//到了这个位置就不超速了，但是需要判断区间是否开：速度到这里刚好降为零就是开
answers/GD-S03108/detect/detect.cpp:75: while(lp < rp){//找探测到这辆车的第一个探测器
answers/GD-S03108/detect/detect.cpp:89: while(lp < rp){//找探测到这辆车的最后一个探测器
answers/GD-S00508/detect/detect.cpp:56: long long v2 = c[i].v * c[i].v + 2 * c[i].a * (L + 1 - c[i].d); // 鏈€熷害^2
answers/GD-S00508/detect/detect.cpp:76: // 杩欎釜涔熻鍗′簡.
answers/GD-S00508/detect/detect.cpp:126: // !娉ㄦ剰娓呯┖鏁扮粍!
answers/GD-S00508/detect/detect.cpp:198:16:36 璋冭瘯瀹屾垚
answers/GD-S00938/detect/detect.cpp:21: if (o > x) d[++l].l = y, d[l].r = L;//由于负数除法会向上取整所以要加防错
answers/GD-S00938/detect/detect.cpp:23: k = y+(x*x-o*o)/(2*p)+1;//瞬时速度要“超过”限速才算
answers/GD-S00938/detect/detect.cpp:40: //获取被检测超速车辆
answers/GD-S00938/detect/detect.cpp:45: for (l2=0, i=1; i<=l; i++) {//将被检测超速的车记录下来
answers/GD-S00938/detect/detect.cpp:51: h[i] = min(d[i].r, h[i+1]);//记录后方右端点最小值
answers/GD-S00938/detect/detect.cpp:53: for (l=0, i=1; i<l2; i++) {//若后方有比自己更小的区间，
answers/GD-S00938/detect/detect.cpp:54: //满足了更小的区间就当然满足了自己的区间，因此本区间可以不加入考虑
answers/GD-S00938/detect/detect.cpp:58: //现在我们就有了l个互不包含，左、右端点都从小到大超速区间
answers/GD-S00938/color/color.cpp:14: for (i=k; i>=1; i--) {//往前搜直到即将出现两个相同数为止
answers/GD-S02897/detect/detect.cpp:15:int fdn(int i,int l,int r){//最小的超速
answers/GD-S02897/detect/detect.cpp:24:int fdx(int i,int l,int r){//最大的超速
answers/GD-S02897/color/color.cpp:11:ll dp[minn][minn];//当前，上一个与当前异色的位置
answers/GD-S02897/color/color.cpp:16: for(int j=1;j<i_1;j++){//上一个与当前同色
answers/GD-S02897/color/color.cpp:18: for(int k=0;k<j;k++){//上一个与j异色
answers/GD-S02897/color/color.cpp:24: //上一个与当前同色是i-1
answers/GD-S02897/color/color.cpp:35:int f[mixn][mixn][2];//i，上一个与当前异色的a,b/r
answers/GD-S02897/color/color.cpp:44: //与上一个一样颜色：
answers/GD-S02897/color/color.cpp:46: for(int k=0;k<=maxa;k++){//k是i-1的上一个异色
answers/GD-S02897/color/color.cpp:51: //与上一个不同颜色:
answers/GD-S01811/detect/detect.cpp:15://16:49 A了！
answers/GD-S01811/detect/detect.cpp:35: if(suma==n){//均为匀速行驶 3,4
answers/GD-S01811/detect/detect.cpp:45: }// 1,2 小数据
answers/GD-S01811/detect/detect.cpp:77: ld sp=sqrt(v[i]*v[i]+2*a[i]*s);//瞬时速度
answers/GD-S01811/arena/arena.cpp:15: if(d[i][j/2+1]=='0'){//j为擂主
answers/GD-S01811/arena/arena.cpp:21: }else{//j+1为擂主
answers/GD-S03068/detect/detect.cpp:14: double h,t;//超速区间端点
answers/GD-S03068/detect/detect.cpp:15: bool fr,bk;//是否包含端点
answers/GD-S03068/detect/detect.cpp:58:// O(cnt),idx单调不减 做法，但不知道后面如何继续
answers/GD-S01779/duel/duel.cpp:16: // 只剩下一个种族能发力
answers/GD-S00693/detect/detect.cpp:1:// 澶氭祴娓呯┖
answers/GD-S01504/detect/detect.cpp:1:// 佛祖保佑 上帝保佑
answers/GD-S01504/duel/duel.cpp:1:// 佛祖保佑 上帝保佑
answers/GD-S01504/color/color.cpp:1:// 佛祖保佑 上帝保佑
answers/GD-S01504/arena/arena.cpp:1:// 佛祖保佑 上帝保佑
answers/GD-S02584/color/color.cpp:5:int dp[N][2];//dp[i][j]是第i个数字选择是否同色所能得到的最大值；
answers/GD-S02578/detect/detect.cpp:59: if(dxl[i + 1].first > dxl[i].second)//无重合
answers/GD-S02578/detect/detect.cpp:61: else if(dxl[i + 1].second > dxl[i].second){ //部分重合
answers/GD-S00970/detect/detect.cpp:1:// 首先将问题转化为每个车有一段超速区间 [l, r]，若没有点与这个区间有交，则称这个区间是无用的
answers/GD-S00970/detect/detect.cpp:2:// 计算出所求第一问后删去所有无用区间，然后以右端点为关键字将区间排序，开始大力贪心！
answers/GD-S00970/detect/detect.cpp:3:// 首先在已经确定要选的点集内找一下，若没有点在这个区间内则需再选一个点。
answers/GD-S00970/detect/detect.cpp:4:// 选点时，选取可以选的点中最靠右的点。
answers/GD-S00970/detect/detect.cpp:5:// 正确性可以感受到，稳妥起见有时间再拍一下。
answers/GD-S00970/detect/detect.cpp:6:// 注意精度问题。
answers/GD-S00970/color/color.cpp:2:// 显然有 n^3 ~ n^2 做法，写了用来对拍。
answers/GD-S00970/color/color.cpp:3:// 设 dp[i][j][k] 表示枚举到 i，上一个颜色为红色的为 j，上一个颜色为蓝色的为 k，目前的最大获益。
answers/GD-S00970/color/color.cpp:4:// 然后发现其实设两维颜色状态是不必要的。设 dp[i][j][0/1] 表示枚举到 i ，当前颜色为红色或蓝色，上一个另一种颜色的位置为 j，目前的最大获益。
answers/GD-S00970/color/color.cpp:5:// 显然转移 O(1)，可以到 O(n^2)。
answers/GD-S00970/color/color.cpp:6:// 注意到会产生贡献的数对形如若干条链，而这些链的总长为 O(n)，显然上述暴力枚举了许多无用数对，十分浪费。
answers/GD-S00970/color/color.cpp:7:// 不过貌似用线段树不太能直接维护这个？其实可以？把塞进线段树内的编号按颜色重排一下然后其实是区间查？
answers/GD-S00970/color/color.cpp:8:// 先润去看T4了，待会再继续想。
answers/GD-S00970/arena/arena.cpp:2:// 题目读了好久才读懂……
answers/GD-S00970/arena/arena.cpp:3:// 首先注意到这个信息拥有无与伦比的半群性质，人话，很容易合并。
answers/GD-S00970/arena/arena.cpp:4:// 对于擂台形成的树，已经就是一棵线段树了。
answers/GD-S00970/arena/arena.cpp:5:// 维护区间信息 {op, val} 表示里面是否有不确定的数，若有不确定的数，则直接将编号加和，若没有，则视此轮规则取一个。
answers/GD-S00970/arena/arena.cpp:6:// 注意到不能简单将编号加和，因为可能存在一个数未来可能需要当擂主但是其小于那轮所需值，
answers/GD-S00970/arena/arena.cpp:7:// 但是每个数到根所需的值都是确定的，直接把 tag 全推了即可。
answers/GD-S00970/arena/arena.cpp:8:// TestCase 比较多的时候可能不能直接 update，暂时不知道怎么处理，有点麻烦的说……
answers/GD-S00970/arena/arena.cpp:9:// 把 tag 全推了，具体来说，若一个已确定的值不可能到根，则直接置为 0
answers/GD-S00970/arena/arena.cpp:10:// 嗯？那这个好像是单点修改区间查，BIT 维护一下？
answers/GD-S00970/arena/arena.cpp:11:// 其实并不是，可能会出现区间合并的时候两个元素都符合要求但因为此轮规则所以被迫选出一个的情况，还是要用线段树大力维护。
answers/GD-S00970/arena/arena.cpp:12:// 刚刚去外面炫了一个士力架，瞬间清醒了。
answers/GD-S00970/arena/arena.cpp:13:// 维护的和查询的都是二的整数次幂。
answers/GD-S00970/arena/arena.cpp:14:// 所以查询时不会拆出两个深度不同的区间，按照 push_up 的方法维护即可。
answers/GD-S00970/arena/arena.cpp:15:// 然鹅实际上暴力都打不完了……
answers/GD-S00970/arena/arena.cpp:17:// 这下子完蛋了完蛋了我的暴力分呜哇哇QAQAQ
answers/GD-S02127/color/color.cpp:40:我想要种一棵香蕉树，上面挂满我的所有祝福
answers/GD-S03251/detect/detect.cpp:115://17：36 写完B 60分 但是第五个样例挂了
answers/GD-S03251/detect/detect.cpp:116://17：41 调过了但没完全调过
answers/GD-S03251/detect/detect.cpp:117://18：06 性质A推错了
answers/GD-S03251/duel/duel.cpp:24://14:40：过A，会赢的 ！
answers/GD-S03084/detect/detect.cpp:15: int cnt=0;//计算超速车辆
answers/GD-S03084/detect/detect.cpp:25: int cnt=0;//计算超速车辆
answers/GD-S03084/detect/detect.cpp:40: double td=(double)(v[i]-V)/(double)a[i];//减速时间
answers/GD-S03084/detect/detect.cpp:43: else { //中途停下来
answers/GD-S03084/detect/detect.cpp:86: int cnt=0;//计算加速匀速超速车辆（只用最后一个即可
answers/GD-S03084/detect/detect.cpp:97: double td=(double)(v[i]-V)/(double)a[i];//减速时间
answers/GD-S03084/detect/detect.cpp:100: else { //中途停下来
answers/GD-S01627/duel/duel.cpp:9:// 因此，将攻击力排序，然后令第二小的数减去第一小的数即可
answers/GD-S01627/duel/duel.cpp:10:// 桶排序，将攻击力从小到大排序，从后往前减
answers/GD-S01627/duel/duel.cpp:11:// 那么问题来了，怎么去设这个贪心？(
answers/GD-S01627/duel/duel.cpp:16:// 将小数组减去大数组，剩下的全部相加即可。
answers/GD-S01627/color/color.cpp:5:// 染色
answers/GD-S01627/color/color.cpp:6:// 1 2 1 注意到，若a[i]前不存在i,必为 0。
answers/GD-S01627/color/color.cpp:7:// 那么，对于上面的情况直接continue，数组a[i]最后数量为 1 的就没必要考虑了。
answers/GD-S01627/color/color.cpp:8:// 注意到可以暴力解前面的
answers/GD-S01627/color/color.cpp:9:// 从贪心的角度看，应该要最接近的两个数字涂同一种颜色的分值能更大化
answers/GD-S01627/color/color.cpp:10:// 但是需要考虑涂色后对其他的影响
answers/GD-S01627/color/color.cpp:14:// 因此，满足条件的两个之间的颜色应该不一样
answers/GD-S01627/color/color.cpp:15:// 所以正解应该是区间dp，但是维护很麻烦，不，应该说不会写(
answers/GD-S01627/color/color.cpp:16:// 完了，不会写区间了。
answers/GD-S01627/color/color.cpp:17:// 先从区间的概念出发。
answers/GD-S01627/color/color.cpp:18:// 设 f[i1][j1][k] 为区间 i1 , j1 下颜色k的最大值 , dp[i] 为目前 1-i 能达到的最大值
answers/GD-S01627/color/color.cpp:19:// 对于另一组成立的最靠近 i1 和 j1 的 f[i2][j2][k] (i2 < i1 < j1 < j2)
answers/GD-S01627/color/color.cpp:21:// 那么，设另一个数组 g[i] , 寻找另一组使其成立的数组。
answers/GD-S01627/color/color.cpp:22:// 也就是 dp[i] = max(f[1][i][1] + f[1][i][2] , f[1][g[i]][1] + f[1][g[i]][2]);
answers/GD-S01627/color/color.cpp:24:// 下面寻找一下 f[i][j][1] 与 f[i][j][2] 的关系。
answers/GD-S01627/color/color.cpp:27:// 然后我们惊人的发现思路好像错了。
answers/GD-S01627/color/color.cpp:28:// 换个思路。
answers/GD-S01627/color/color.cpp:29:// 首先，我们从 “因此，满足条件的两个之间的颜色应该不一样 ”出发，寻找 f[i][j][1];
answers/GD-S01627/color/color.cpp:30:// 那么，另一种颜色就存在于 f[i+1][j-1][2]，更准确一点，就只是寻找 i + 1 和 j - 1 两个点或者连通点。
answers/GD-S01627/color/color.cpp:31:// 不妨全部涂红，寻找中间的点，然后将中间的全变为蓝色，接着进行进一步讨论
answers/GD-S01627/color/color.cpp:32:// 3 5 1 5 2 1 2 4 全为红时，找到 5 和 3 ，并将中间的全部染成蓝色
answers/GD-S01627/color/color.cpp:33:// 那么现在应该想的下一步就应该是全部为红时的情况有什么
answers/GD-S01627/color/color.cpp:34:// 先将 3 4 去除
answers/GD-S01627/color/color.cpp:36:// 设个队列，如果队首与队尾相同，弹出队首。
answers/GD-S01627/color/color.cpp:37:// 结果发现队列写错了，写完输出 0 了，令人忍俊不禁。
answers/GD-S01627/color/color.cpp:38:// 不写了。
answers/GD-S01627/arena/arena.cpp:5:// 显然，我不会写。
answers/GD-S01627/arena/arena.cpp:6:// 连分析都不会分析写什么代码(
answers/GD-S00413/detect/detect.cpp:1:#include<bits/stdc++.h>//估分：60
answers/GD-S00413/duel/duel.cpp:1:#include<bits/stdc++.h>//估分：100
answers/GD-S00413/color/color.cpp:1:#include<bits/stdc++.h>//估分：20
answers/GD-S01221/detect/detect.cpp:40: int tt=-1;//判断是否为特殊，-1为加速度全小于，0为加速度为0，1为》》。
answers/GD-S01741/detect/detect.cpp:13: int sum=0;//超速车辆数
answers/GD-S01741/detect/detect.cpp:31: int sum=0;//超速车辆数
answers/GD-S03232/detect/detect.cpp:1:#include<bits/stdc++.h>//记得多测清空
answers/GD-S00616/detect/detect.cpp:8://对此题的感想：考验我无比的耐心和物理水平的时候到了！
answers/GD-S00616/detect/detect.cpp:61: if(cmp(c[i].hl,c[i].hr)){//超速的地方其实已经出去了
answers/GD-S00616/detect/detect.cpp:66: else{//匀减速
answers/GD-S01625/color/color.cpp:6:ll f[N][2][N][2],a[N];//第i个数，自己为j，前面有k个p的最大贡献
answers/GD-S01540/detect/detect.cpp:41:int find_ld(double x)//对上补充，可取等
answers/GD-S01540/detect/detect.cpp:139: op=find_rd(d);//可取等
answers/GD-S01540/detect/detect.cpp:145: op=find_rd(d);//可取等
answers/GD-S01540/detect/detect.cpp:146: ed=find_l( d + 1.0*(v+maxv) * (v-maxv) / (-2*a) );//不可取等
answers/GD-S01540/detect/detect.cpp:151: op=find_r( d + 1.0*(maxv+v) * (maxv-v) / (2*a) );//不可取等
answers/GD-S01540/color/color.cpp:2:不会打了发会疯qaq
answers/GD-S01540/color/color.cpp:4:想回家玩fl studio qaq，上周一个demo混音一坨
answers/GD-S01540/color/color.cpp:5:怎么周围都是xxs感觉我好拉qaq
answers/GD-S01540/color/color.cpp:6:想谈恋爱了qaq
answers/GD-S01540/color/color.cpp:7:算了不疯了还要打暴力
answers/GD-S01540/color/color.cpp:8:T4看不懂，又回来发疯了
answers/GD-S01540/color/color.cpp:9:半个小时再憋个好点的暴力，棒！
answers/GD-S02987/detect/detect.cpp:1:// CSP-S 2024 游记
answers/GD-S02987/detect/detect.cpp:2:// T1 感觉就 CF div 2 A 或者 B 的难度，不过并没有拿出cf时的手速，花了13分钟
answers/GD-S02987/detect/detect.cpp:3:// T2 过程有点复杂，但是考虑起来挺简单的，先将每个会超的处理出来，然后贪心
answers/GD-S02987/detect/detect.cpp:4:// T3 dp，观察一下优化到 O(n)
answers/GD-S02987/detect/detect.cpp:5:// T4 直接枯竭了，感觉没有什么拿分空间
answers/GD-S02987/detect/detect.cpp:8:// 15:52 样例全过
answers/GD-S02987/duel/duel.cpp:1:// 14:43 样例全过
answers/GD-S02987/arena/arena.cpp:1:// 到这里脑袋就枯竭了，不打了
answers/GD-S02987/arena/arena.cpp:2:// 暴力上也感觉没什么拿分的空间
answers/GD-S00243/detect/detect.cpp:21:// 第i辆车的超速路段
answers/GD-S00111/detect/detect.cpp:16: L(i,1,m){ // 探测器编号
answers/GD-S00111/color/color.cpp:45://unordered_map<int,int> lst; // 记录某个数最后出现的位置
answers/GD-S00111/color/color.cpp:46://int f[2010][2010]; // f[i][j] 以 i 结尾后缀有 j 个是红色的最大分值
answers/GD-S02214/duel/duel.cpp:21: while(!q.empty())//里面的就是没攻击过的
answers/GD-S00144/detect/detect.cpp:38: if(cars[i].v<=V){ // 暂未超速
answers/GD-S00144/detect/detect.cpp:43: else { // 已超速
answers/GD-S02532/duel/duel.cpp:18: // 这头文件到底怎么拼！！？
answers/GD-S02532/color/color.cpp:53: bool color[LEN]; // true为红
answers/GD-S00634/color/color.cpp:19: scanf("%d",&x); //x一定要选的最大分数
answers/GD-S02408/detect/detect.cpp:3: Author:广州市铁一中学_袁亦均
answers/GD-S02408/duel/duel.cpp:3: Author:广州市铁一中学_袁亦均
answers/GD-S02408/color/color.cpp:3: Author:广州市铁一中学_袁亦均
answers/GD-S02408/arena/arena.cpp:3: Author:广州市铁一中学_袁亦均
answers/GD-S01564/color/color.cpp:32:f[i][j][k]: 当前选完 i， 红色最后是 J, 蓝色最后是 K
answers/GD-S03493/duel/duel.cpp:3:int n,t,m;//m:攻击力的数量，桶索引
answers/GD-S03493/duel/duel.cpp:13: if(mapp[t]==0) addres[++m]=t;//桶索引
answers/GD-S03493/duel/duel.cpp:23: if(aa>=bb) mapp[addres[i-1]]=0;//杀光了，多余的killer自己不杀人地打（不记录）
answers/GD-S03493/duel/duel.cpp:25: mapp[addres[i-1]]-=aa;//没杀干净，只杀一部分
answers/GD-S03493/duel/duel.cpp:26: mapp[addres[i]]+=mapp[addres[i-1]];//把前面没杀完的加到一起，等价的
answers/GD-S00292/detect/detect.cpp:90://加速度下的路程公式：((加速度-1的绝对值)平方-初速度平方）/(2*加速度)
answers/GD-S00292/duel/duel.cpp:1://15个点可过 有hack
answers/GD-S03009/detect/detect.cpp:13: //最小的大于等于x的p[i]
answers/GD-S03009/detect/detect.cpp:27: //最大的小于等于x的p[i]
answers/GD-S03009/detect/detect.cpp:79: //超过V才算超速，等于V不算
answers/GD-S03009/duel/duel.cpp:1://t1 每次由次小干掉最小
answers/GD-S00259/detect/detect.cpp:11:int up(double k)//第一个超过的监控 >=
answers/GD-S00259/detect/detect.cpp:23:int up2(double k)//第一个超过的监控 >
answers/GD-S00259/detect/detect.cpp:35:int down(double k)//最后一个监控 <
answers/GD-S00180/detect/detect.cpp:6: int d,v,a;//d：驶入;
answers/GD-S00467/detect/detect.cpp:31: for(int t = 0; t < (1 << m); t++){ //枚举第i个测速仪是否启用
answers/GD-S00467/color/color.cpp:13: for(int t = 0; t < (1 << n); t++){ //第i位为1染红，否则染蓝
answers/GD-S00467/arena/arena.cpp:72: for(int j = 1; j <= k; j++){ //第j轮比赛
answers/GD-S00863/detect/detect.cpp:6:int d[N],v[N],a[N],p[N],cb[N];//cb 第i辆车被哪个firstly拍到
answers/GD-S00863/detect/detect.cpp:22: if(p[i]>=d[num]){//对于所有在出发点以后的测速器，计算在它们那的速度
answers/GD-S00043/duel/duel.cpp:39: if(c[y])//濡傛灉鏈変笉鑳芥敾鍑荤殑
answers/GD-S00043/duel/duel.cpp:41: tmp--;//姝讳簡
answers/GD-S00043/duel/duel.cpp:48: tmp--;//姝讳簡
answers/GD-S00043/duel/duel.cpp:51: b[y]--;//姝讳簡
answers/GD-S02173/detect/detect.cpp:30: if(all_zero) //如果车辆都作匀速运动
answers/GD-S02173/detect/detect.cpp:41: else if(no_below) //如果车辆都作等加速匀速运动
answers/GD-S02173/color/color.cpp:5:bool is_red[200005]; //true为红，false为蓝
answers/GD-S02612/detect/detect.cpp:22:bool b[N][N];//j能否检查出i车超速
answers/GD-S02612/detect/detect.cpp:23:int ok[N];//i是否已被检查出超速 （个数）
answers/GD-S01887/color/color.cpp:5:ll dp[2][N][N],T,n,a[N],ans,dt[2][N][15];//dp[i][j][k]表示第j轮,上一轮是i颜色,另一种颜色为j的最大得分
answers/GD-S03076/detect/detect.cpp:8:int b[5001][2];//[0]存编号,[0]存可测到的数量
answers/GD-S03076/detect/detect.cpp:48: }//车辆数据处理完成
answers/GD-S03076/detect/detect.cpp:66: //第一个数字
answers/GD-S03076/detect/detect.cpp:111: //调试代码
answers/GD-S03076/duel/duel.cpp:6:int b[100010][2];//b[i][0]存攻守，b[i][1]存怪兽数量
answers/GD-S03076/color/color.cpp:13: //选红色
answers/GD-S03076/color/color.cpp:20: //选蓝色
answers/GD-S00898/detect/detect.cpp:72:// cout<<"测速："<<p[pp]<<"\n";
answers/GD-S00898/detect/detect.cpp:158://// cout<<"测速："<<p[pp]<<"\n";
answers/GD-S00554/detect/detect.cpp:5://显然，a<0的，仅在小于等于v之前可能超速
answers/GD-S00554/detect/detect.cpp:6://a>0的 ,在大于v后都可能超时
answers/GD-S00554/detect/detect.cpp:7://想要关闭测速仪，当且仅当其可检测超速车都有在其他点被检测超速
answers/GD-S00554/detect/detect.cpp:9:int n,m,L,V;//车数,测速机数,路长,限速
answers/GD-S00554/detect/detect.cpp:10:int d[MAXN],v[MAXN],a[MAXN],p[MAXM];//起点,初速,起动速,测速点
answers/GD-S00554/detect/detect.cpp:11:int l[MAXN],r[MAXN]; //超速区间(数值)
answers/GD-S00554/detect/detect.cpp:12:int z[MAXM],y[MAXM];//被检测超速的区间
answers/GD-S00554/detect/detect.cpp:13:int vis[MAXN]; //可能用于测评的
answers/GD-S00554/detect/detect.cpp:14:int ans1,ans2;//超速车辆数与可关停测速仪数
answers/GD-S00554/detect/detect.cpp:19:void pd(int);inline int sc(int,int);//判断
answers/GD-S00554/detect/detect.cpp:20:void work(){//多测记得清空
answers/GD-S00554/detect/detect.cpp:34: pd(i);//计算超速区间并找出被测速区间
answers/GD-S00554/duel/duel.cpp:4:int n,r[MAXN];//怪兽数量及攻击力(假设怪兽们全都是link怪兽)
answers/GD-S00554/duel/duel.cpp:5:int a[MAXN],b[MAXN],ul;//数值及其数量（离散化）,总数
answers/GD-S00554/duel/duel.cpp:6:int s[MAXN];//比a[i]小的数数量
answers/GD-S00554/duel/duel.cpp:11: r[0]=-1;//预防r[1]==0;
answers/GD-S00554/duel/duel.cpp:15: for(int i=1;i<=n;i++){//离散化
answers/GD-S00554/duel/duel.cpp:20: for(int i=1;i<=ul;i++){//查找能击破的怪兽，否则等价于不攻击
answers/GD-S00554/duel/duel.cpp:21: s[i]=s[i-1]+b[i-1];//比当前怪兽攻击力小的怪兽数量
answers/GD-S00554/duel/duel.cpp:23: if(s[i]>=b[i])ans-=b[i],s[i]-=b[i];//如果能让当前怪兽都攻击则攻击
answers/GD-S00554/duel/duel.cpp:24: else ans-=s[i],s[i]=0;//否则尽可能的攻击
answers/GD-S00554/color/color.cpp:4://使每一个数最左相同的数尽可能染上同色
answers/GD-S00025/duel/duel.cpp:34: //统计
answers/GD-S02648/color/color.cpp:5: //我叫郝大力，我以为多刷c++就可以获得一个好成绩，要不是我现在在考试，我差点就信了。
answers/GD-S02648/arena/arena.cpp:5: //疑似c++对我火力全开哈。
answers/GD-S00568/detect/detect.cpp:8:// 测速仪gi包含于 g(i+1) / g(i-1) 时，gi可关闭
answers/GD-S00568/arena/arena.cpp:12:我想上2024迷惑行为大赏
answers/GD-S00568/arena/arena.cpp:14:现在是17:50，距离今晚Arknights前瞻还有2h10min
answers/GD-S00568/arena/arena.cpp:15:我用这题的分数来换今晚能看到后面有异格棘刺的ss
answers/GD-S00568/arena/arena.cpp:16:棘门！
answers/GD-S00568/arena/arena.cpp:19:别急着走，来个猜歌挑战吧
answers/GD-S00568/arena/arena.cpp:22:不如就化身为风
answers/GD-S00568/arena/arena.cpp:23:卷狂沙 侵天幕
answers/GD-S00568/arena/arena.cpp:24:吹醒那泉下望乡的战骨
answers/GD-S00568/arena/arena.cpp:25:昨日边关犹灯火
answers/GD-S00568/arena/arena.cpp:26:眼前血海反覆
answers/GD-S00568/arena/arena.cpp:27:千万人跌落青史 隔世号呼
answers/GD-S00568/arena/arena.cpp:28:于是沸血重剑共赴
answers/GD-S00568/arena/arena.cpp:29:斩以雷霆之怒
answers/GD-S00568/arena/arena.cpp:30:肩背相抵破阵开路
answers/GD-S00568/arena/arena.cpp:31:万古同歌枯
answers/GD-S00568/arena/arena.cpp:34:当烟雾 随晨光飘散
answers/GD-S00568/arena/arena.cpp:35:枕畔的湖已风干
answers/GD-S00568/arena/arena.cpp:36:期待已退化成等待
answers/GD-S00568/arena/arena.cpp:37:而我告别了突然
answers/GD-S00568/arena/arena.cpp:38:当泪痕 勾勒着遗憾
answers/GD-S00568/arena/arena.cpp:39:回忆夸饰着伤感
answers/GD-S00568/arena/arena.cpp:40:落花铺成一片红色地毯
answers/GD-S00568/arena/arena.cpp:41:终于我们不再为了生命狂欢
answers/GD-S00568/arena/arena.cpp:42:为爱情狂乱
answers/GD-S00568/arena/arena.cpp:43:然而青春彼岸
answers/GD-S00568/arena/arena.cpp:44:盛夏正要一天一天一天的灿烂
answers/GD-S00568/arena/arena.cpp:47:越来越大的企业
answers/GD-S00568/arena/arena.cpp:48:越来越小的公园
answers/GD-S00568/arena/arena.cpp:49:越来越深的幻灭
answers/GD-S00568/arena/arena.cpp:50:英雄 电影 情节
answers/GD-S00568/arena/arena.cpp:51:有没有一种信念
answers/GD-S00568/arena/arena.cpp:52:有没有一句誓言
answers/GD-S00568/arena/arena.cpp:53:呼唤黎明的出现
answers/GD-S00568/arena/arena.cpp:56:雨后的天空中又出现彩虹
answers/GD-S00568/arena/arena.cpp:57:天使的恩惠亲吻着世间万众
answers/GD-S00568/arena/arena.cpp:58:不再追问你为何不能停留
answers/GD-S00568/arena/arena.cpp:59:微笑看见 你已不见
answers/GD-S00568/arena/arena.cpp:62:哪朵玫瑰没有荆棘
answers/GD-S00568/arena/arena.cpp:63:最好的报复是美丽
answers/GD-S00568/arena/arena.cpp:64:最美的盛开是反击
answers/GD-S00568/arena/arena.cpp:65:别让谁去改变了你
answers/GD-S00568/arena/arena.cpp:66:你是你或是妳都行
answers/GD-S00568/arena/arena.cpp:67:会有人真心的爱你
answers/GD-S00568/arena/arena.cpp:71:差点忘了传统
answers/GD-S00568/arena/arena.cpp:83: 空无一人的大街
answers/GD-S00568/arena/arena.cpp:84: 闯入无人婚纱店
answers/GD-S00568/arena/arena.cpp:85: 为你披上雪白誓言
answers/GD-S00568/arena/arena.cpp:86: 世界已灰飞烟灭
answers/GD-S00568/arena/arena.cpp:88: 你是真的 或是我的 幻觉
answers/GD-S00568/arena/arena.cpp:89: 时光遗忘的背面
answers/GD-S00568/arena/arena.cpp:90: 独坐残破的台阶
answers/GD-S00568/arena/arena.cpp:91: 哪个乱世没有离别
answers/GD-S00568/arena/arena.cpp:92: 天空和我的中间
answers/GD-S00568/arena/arena.cpp:93: 只剩倾盆的思念
answers/GD-S00568/arena/arena.cpp:94: 如果后悔 不能后退
answers/GD-S00568/arena/arena.cpp:95: 是不是就只能往前
answers/GD-S00568/arena/arena.cpp:96: 在失去你的风景里面
answers/GD-S00568/arena/arena.cpp:97: 你却占据了每一条街
answers/GD-S00568/arena/arena.cpp:98: 一步步曾经 一步步想念
answers/GD-S00568/arena/arena.cpp:99: 在脚下蔓延
answers/GD-S00568/arena/arena.cpp:100: 在充满你的回忆里面
answers/GD-S00568/arena/arena.cpp:101: 我独自一人和眼泪周旋
answers/GD-S00568/arena/arena.cpp:102: 一步步走过当时心愿
answers/GD-S00568/arena/arena.cpp:103: 格林威治大钟前
answers/GD-S00568/arena/arena.cpp:104: 归零超载的伤悲
answers/GD-S00568/arena/arena.cpp:105: 背着我和我的诺言
answers/GD-S00568/arena/arena.cpp:106: 一起计划的路线
answers/GD-S00568/arena/arena.cpp:107: 对照孤单的旅店
answers/GD-S00568/arena/arena.cpp:108: 一声晚安 却又唤醒泪腺
answers/GD-S00568/arena/arena.cpp:109: 时代广场的跨年
answers/GD-S00568/arena/arena.cpp:110: 颐和花季的蓝天
answers/GD-S00568/arena/arena.cpp:111: 数着愿望在你指尖
answers/GD-S00568/arena/arena.cpp:112: 当时有多少心愿
answers/GD-S00568/arena/arena.cpp:113: 就有多少的残缺
answers/GD-S00568/arena/arena.cpp:114: 如果后悔 不能后退
answers/GD-S00568/arena/arena.cpp:115: 是不是就只能往前
answers/GD-S00568/arena/arena.cpp:116: 在失去你的风景里面
answers/GD-S00568/arena/arena.cpp:117: 你却占据了每一条街
answers/GD-S00568/arena/arena.cpp:118: 一步步曾经 一步步想念
answers/GD-S00568/arena/arena.cpp:119: 在脚下蔓延
answers/GD-S00568/arena/arena.cpp:120: 在充满你的回忆里面
answers/GD-S00568/arena/arena.cpp:121: 我独自一人和眼泪周旋
answers/GD-S00568/arena/arena.cpp:122: 一步步走向当时心愿
answers/GD-S00568/arena/arena.cpp:123: 生如浮萍般卑微
answers/GD-S00568/arena/arena.cpp:124: 爱却潮水般壮烈
answers/GD-S00568/arena/arena.cpp:125: 我要为你爬上最险山岳
answers/GD-S00568/arena/arena.cpp:126: 走过最崎岖眷恋
answers/GD-S00568/arena/arena.cpp:127: 一步一步穿越
answers/GD-S00568/arena/arena.cpp:128: 在失去你的风景里面
answers/GD-S00568/arena/arena.cpp:129: 你却占据了整个世界
answers/GD-S00568/arena/arena.cpp:130: 每一张相片 每一个发现
answers/GD-S00568/arena/arena.cpp:131: 每一滴眼泪
answers/GD-S00568/arena/arena.cpp:132: 在充满你的回忆里面
answers/GD-S00568/arena/arena.cpp:133: 我独自流浪海角天边
answers/GD-S00568/arena/arena.cpp:134: 一步步走向孤单的明天
answers/GD-S00568/arena/arena.cpp:135: 也许在来生的某个明天
answers/GD-S00568/arena/arena.cpp:136: 我们能再写新的起点
answers/GD-S00568/arena/arena.cpp:137: 一步步走向当时心愿
answers/GD-S00568/arena/arena.cpp:138: 一步步完成最美残缺
answers/GD-S00512/detect/detect.cpp:42: // 最近的一个摄像头
answers/GD-S00512/detect/detect.cpp:46: // 后面都没有了，超不超速无所谓（
answers/GD-S00512/detect/detect.cpp:52: // 良好市民绝对不会超速
answers/GD-S00512/detect/detect.cpp:55: int x=(1ll*lst[i].v*lst[i].v-1ll*V*V)/2/(-lst[i].a); // 超速情况下能走的最远距离
answers/GD-S00512/detect/detect.cpp:56: // 看能被哪几个抓包
answers/GD-S00512/detect/detect.cpp:58: if(ppp==pp&&p[ppp]-lst[i].d>x)continue; // 这种抓不到
answers/GD-S00512/detect/detect.cpp:72: // 这种就不用说了）
answers/GD-S00512/detect/detect.cpp:83: // 加速就看什么时候会超速
answers/GD-S00512/detect/detect.cpp:85: // 上来就超速
answers/GD-S00512/detect/detect.cpp:95: if(x>p[m]-lst[i].d)continue; // 这种管不了
answers/GD-S00512/detect/detect.cpp:96: // 看能被哪几个抓包
answers/GD-S00512/detect/detect.cpp:113: // 想不出来了，直接暴力（悲
answers/GD-S00512/color/color.cpp:12:// 我什么都做不到）））
answers/GD-S00750/detect/detect.cpp:43: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/detect/detect.cpp:44: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/detect/detect.cpp:45: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/duel/duel.cpp:54: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/duel/duel.cpp:55: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/duel/duel.cpp:56: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/color/color.cpp:39: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/color/color.cpp:40: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/color/color.cpp:41: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/arena/arena.cpp:24: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/arena/arena.cpp:25: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00750/arena/arena.cpp:26: 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！ 考神附体！
answers/GD-S00181/detect/detect.cpp:3:const int MAXN=1e5+5;//照特殊情况A来做，可以骗得20分
answers/GD-S00181/detect/detect.cpp:13: int flag=1;//判断是否为特殊情况A
answers/GD-S00181/detect/detect.cpp:23: if (flag)//特殊情况A 对每一辆车只需判断是否全程超速
answers/GD-S00181/detect/detect.cpp:31: else//赌博法！ 赌测试数据没有超车且只需留下一个测速仪！
answers/GD-S00181/detect/detect.cpp:39:我叫夯大力，我本以为我这次比赛100%趋势 要不是这次比赛题目水的要命 我差点就信了！
answers/GD-S00181/detect/detect.cpp:42:听说虔诚地膜拜CCF可以获得额外分数)
answers/GD-S00181/detect/detect.cpp:43:但愿分数线和去年一样
answers/GD-S00181/detect/detect.cpp:44:这么骗分也只能拿个65分（当然只是下限）
answers/GD-S00181/detect/detect.cpp:45:千万不要爆蛋啊！！！！！！！！！！！！
answers/GD-S00181/duel/duel.cpp:5:bool find(int num)//O(m^2) 预估45分
answers/GD-S00181/color/color.cpp:16: //不会做怎么办? 有了！
answers/GD-S00181/color/color.cpp:18: //我简直是添柴！ 再次赌博
answers/GD-S03022/detect/detect.cpp:4:int n[25]={0},m[25]={0},l[25]={0},vv[25]={0},ans1[25]={0},ans2[25]={0};//车辆数量、测速仪数量、主干道长度和道路限速;
answers/GD-S03308/detect/detect.cpp:8:/*int b_search(int l,int r,int x){//查找p中第一个大于x的数
answers/GD-S03308/detect/detect.cpp:25: cin>>n>>m>>l>>vtop;//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S03308/duel/duel.cpp:1:#include<bits/stdc++.h>//贪心
answers/GD-S02184/detect/detect.cpp:27://加速度公式
answers/GD-S02184/detect/detect.cpp:30://当位移为(v1*v1-v0*v0)/2a时 瞬时速度为v1
answers/GD-S03524/detect/detect.cpp:13:bool pd2(int k,int m,int v){//直接在离入口最近处判断
answers/GD-S03524/detect/detect.cpp:30:bool pd3(int k,int m,int v){//离入口最远处判断
answers/GD-S03524/detect/detect.cpp:43:void quankai(int n,int m,int l,int v){//全开时
answers/GD-S03524/detect/detect.cpp:46: if(!a[i].jiashudu){//先判断加速度=0的
answers/GD-S03524/detect/detect.cpp:65:void pd4(int k,int m,int v){//因为是还要其超速 ，故看其在哪一处仍超速，并且最远
answers/GD-S03524/detect/detect.cpp:74:void pd5(int k,int m,int v){//因为是还要其超速 ，故看其在哪一处仍超速，并且最远
answers/GD-S03524/detect/detect.cpp:84:void guanbi(int n,int m,int l,int v){//关多少个，同样分类进行，但此时是要符合的最优情况
answers/GD-S03524/detect/detect.cpp:87: if(!a[i].jiashudu){//先判断加速度=0的
answers/GD-S03524/duel/duel.cpp:21: for(int i=2;i<=n;i++){//把最近的打掉
answers/GD-S03524/color/color.cpp:20: for(int k=1;k<=n;k++){//第几个变蓝
answers/GD-S02645/detect/detect.cpp:105://码了一坤时70pts收益不要太低
answers/GD-S02645/arena/arena.cpp:35://预估180pts 真的要退役了啊
answers/GD-S03008/detect/detect.cpp:1://多测记得清空
answers/GD-S03008/detect/detect.cpp:2://是否 long long
answers/GD-S03008/detect/detect.cpp:43: d[i]=read();//驶入点10^6
answers/GD-S03008/detect/detect.cpp:44: v[i]=read();//初速度10^3
answers/GD-S03008/detect/detect.cpp:45: a[i]=read();//加速度+-10^3
answers/GD-S03008/detect/detect.cpp:48: p[i]=read();//测速仪位置
answers/GD-S01818/detect/detect.cpp:129: // 统计超速车数
answers/GD-S01818/detect/detect.cpp:149: // 测速器是原编号
answers/GD-S01818/detect/detect.cpp:150: // 车是编号加测速器数
answers/GD-S01818/color/color.cpp:50:// if(l==r || l==r-1) return 0;//连着的已经判断了不管
answers/GD-S01818/color/color.cpp:109:// // 先扫一遍看相邻的
answers/GD-S03247/detect/detect.cpp:46: lb[i] = lower_bound(pl + 1,pl + m + 1,i) - pl; //记录在pl中第一个大于等于i的数的下标
answers/GD-S03247/duel/duel.cpp:24: s[i + 1] = s[i] + num[i]; //s[i] 表示 num[1]...num[i - 1] 之和
answers/GD-S00788/detect/detect.cpp:37: scanf("%lld%lld%lld",&x,&y,&z);//x起点,y初速,z加速度
answers/GD-S03354/color/color.cpp:11:int col[200005];//0.没颜色 1.红色的 2.蓝色的
answers/GD-S03202/detect/detect.cpp:18: for(int j=m-1;j>=0;j--)//找最近观测点
answers/GD-S03202/detect/detect.cpp:25: d=(a[i][1]-v)/(-1*a[i][2]);//确定减速到v所需时间
answers/GD-S03202/detect/detect.cpp:29: c[z][1]=c[z][1]*10+i;//超速的人
answers/GD-S00423/color/color.cpp:5:long long dp[maxn][2];//dp[i][j]表示将第i个数染成j色的最大值
answers/GD-S01423/color/color.cpp:37://无3个区间相交
answers/GD-S02241/detect/detect.cpp:126: ans++;//需要
answers/GD-S02241/color/color.cpp:24: for(int i=1;i<=n;i++) {//开头
answers/GD-S00303/detect/detect.cpp:45: db tmp=(db)(V*V-v[i]*v[i])/2.0/a[i]+d[i];//超速点
answers/GD-S00303/duel/duel.cpp:23:我是树状数组厨，关注我谢谢
answers/GD-S00303/duel/duel.cpp:24:本来想在这里写一个单log树状数组RMQ的，但是时间不够了
answers/GD-S00303/duel/duel.cpp:25:有兴趣看的私信我（？）
answers/GD-S00303/color/color.cpp:66:宣传一下同机房的大佬——狂暴线段树厨Exp10re
answers/GD-S00968/detect/detect.cpp:47: if(a>0){//加速度大于0
answers/GD-S00968/detect/detect.cpp:55: if(a<=0){//加速度小于0
answers/GD-S00675/detect/detect.cpp:16:int src(int x,int m){//该位置右边的第一个摄像头。不存在就返回一
answers/GD-S00675/detect/detect.cpp:30:int src2(int x,int m){//该位置左边的第一个摄像头。不存在就返回一
answers/GD-S00675/detect/detect.cpp:57: if(a==0){//无加速度的情况
answers/GD-S00675/detect/detect.cpp:58: if(v>vl)cth[i]=(cath){src(d,m),m};//如果已经超速，那区间就是驶入点右侧第一个摄像头到最后一个
answers/GD-S00675/detect/detect.cpp:59: else cth[i]=(cath){-1,-1};//如果未超速，那么不存在需要的摄像头
answers/GD-S00675/detect/detect.cpp:61: else if(a>0){//加速的情况下
answers/GD-S00675/detect/detect.cpp:62: if(v>vl)cth[i]=(cath){src(d,m),m};//如果已经超速，与无加速度同理
answers/GD-S00675/detect/detect.cpp:64: int xloc=d+((vl*vl-v*v)*1.0)/(2*a)+1;//用公式计算开始超速的位置
answers/GD-S00675/detect/detect.cpp:65: cth[i]=(cath){src(xloc,m),m};//区间为开始超速的位置到最后一个
answers/GD-S00675/detect/detect.cpp:69: if(v<=vl)cth[i]=(cath){-1,-1};//如果没超速，且减速，那就不可能超速
answers/GD-S00675/detect/detect.cpp:71: int xloc=d+((v*v-vl*vl)*1.0)/(-2*a);//公式计算开始不超速的位置
answers/GD-S00675/detect/detect.cpp:72: if(d+((v*v-vl*vl)*1.0)/(2*-a)==(d+((v*v-vl*vl))/(2*-a))*1.0)xloc--;//特判，如果位置刚好在整数位，那一位不能算超速
answers/GD-S00675/detect/detect.cpp:73: cth[i]=(cath){src(d,m),src2(xloc,m)}; //区间为驶入点右侧第一个到不超速点左侧第一个
answers/GD-S00675/detect/detect.cpp:78: ans1++;//有摄像头可以拍到则ans1++
answers/GD-S00675/detect/detect.cpp:83: sort(cth+1,cth+n+1,cmp);//依据左端点从小到大给区间排序
answers/GD-S02853/detect/detect.cpp:107: int yy=qwq[j];//摄像头编号
answers/GD-S01726/detect/detect.cpp:14:int lq[N],rq[N];// 不超速的车子就是在 [L+1,L+1]区间内超速
answers/GD-S01726/detect/detect.cpp:16:int pres[M];// 测数前缀和
answers/GD-S01726/detect/detect.cpp:17:int mlq[N];// 每个测速器要管理的 lq 最大的位置
answers/GD-S01726/detect/detect.cpp:30:// 我们只关心车子在什么路段会超速
answers/GD-S01726/detect/detect.cpp:42: // 如果开局就超速
answers/GD-S01726/detect/detect.cpp:48: }// 全路段都超速了
answers/GD-S01726/detect/detect.cpp:49: // 为了客服负数乘以负数的问题
answers/GD-S01726/detect/detect.cpp:50: ll fs = d[i]+((v[i]*v[i] - V*V -2*a[i] - 1) / (-2*a[i]));// 到达这里时才不超速
answers/GD-S01726/detect/detect.cpp:54: // 处理未来可能超速组
answers/GD-S01726/detect/detect.cpp:55: if(a[i] <= 0){// 绝对不会超速！
answers/GD-S01726/detect/detect.cpp:59: ll fs = d[i] + ((V*V - v[i]*v[i]) / (2ll*a[i])) + 1;// 到这个位置 +1 时就超速了
answers/GD-S01726/detect/detect.cpp:63: // 输出每辆车的超速区间
answers/GD-S01726/detect/detect.cpp:67: int pos = upper_bound(p+1,p+m+1,rq[i]) - p - 1;// 第一个小于等于的位置
answers/GD-S01726/detect/detect.cpp:71: // 顶多让 1 帮 2 管，1 没有候选人
answers/GD-S01726/duel/duel.cpp:9:int l,r;// 快慢指针
answers/GD-S01726/color/color.cpp:1:// 记忆化搜索
answers/GD-S01726/color/color.cpp:18: if(idx > n)return ;// 不准超过！！！
answers/GD-S01726/color/color.cpp:19: // 考虑红色
answers/GD-S01726/color/color.cpp:23: // 考虑蓝色
answers/GD-S01726/arena/arena.cpp:32: // 算出真实的 a 数组
answers/GD-S02292/detect/detect.cpp:7:long long ans1,ans2;//超速的车、可关闭的测速器数
answers/GD-S02292/detect/detect.cpp:11: long long lp,rp;//被l到r的测速器检测到
answers/GD-S02292/detect/detect.cpp:48: for(int i=1;i<=n;i++)scanf("%lld%lld%lld",&car[i].start,&car[i].v,&car[i].a);//车起点、速度、加速度
answers/GD-S02292/detect/detect.cpp:49: for(int i=1;i<=m;i++)scanf("%lld",&p[i]);//测速仪位置
answers/GD-S02292/detect/detect.cpp:50: for(int i=1;i<=n;i++)//找超速车量和每辆车能被哪些测速器测到
answers/GD-S02292/detect/detect.cpp:52: if(car[i].start>p[m])continue;//没有测速器
answers/GD-S02292/detect/detect.cpp:53: if(car[i].v<=maxv && car[i].a<0)continue;//一路减速，没有超速
answers/GD-S02292/detect/detect.cpp:54: //一路加速，但到最后一直没有超速
answers/GD-S02292/detect/detect.cpp:56: if(car[i].a==0)//该车加速度为0
answers/GD-S02292/detect/detect.cpp:58: if(car[i].v>maxv && car[i].start<=p[m])//该车一路超速且后面还有测速器
answers/GD-S02292/detect/detect.cpp:60: car[i].lp=erfen_dayudengyu(car[i].start);//找第一个大于等于该车出发点的测速器
answers/GD-S02292/detect/detect.cpp:61: car[i].rp=m;//最后一个测到该车的测速器
answers/GD-S02292/detect/detect.cpp:67: if((maxv*maxv-car[i].v*car[i].v)%(2*car[i].a)==0)//超速点是整数(不包含超速点上的测速器)
answers/GD-S02292/detect/detect.cpp:69: if(car[i].a<0)//该车减速运动(从出发到超速点都超速)
answers/GD-S02292/detect/detect.cpp:73: car[i].lp=erfen_dayudengyu(car[i].start);//找第一个大于等于该车出发点的测速器
answers/GD-S02292/detect/detect.cpp:74: car[i].rp=erfen_xiaoyudengyu(chaosudian);//找第一个小于等于该车超速点-1的测速器
answers/GD-S02292/detect/detect.cpp:76: else//该车加速运动(从加速点到结束都超速)
answers/GD-S02292/detect/detect.cpp:80: car[i].lp=erfen_dayudengyu(chaosudian);//找第一个大于等于该车超速点+1的测速器
answers/GD-S02292/detect/detect.cpp:81: car[i].rp=m;//最后一个测到该车的测速器
answers/GD-S02292/detect/detect.cpp:84: else//无法整除
answers/GD-S02292/detect/detect.cpp:86: if(car[i].a<0)//该车减速运动(从出发到超速点都超速)
answers/GD-S02292/detect/detect.cpp:90: car[i].lp=erfen_dayudengyu(car[i].start);//找第一个大于等于该车出发点的测速器
answers/GD-S02292/detect/detect.cpp:91: car[i].rp=erfen_xiaoyudengyu(chaosudian);//找第一个小于等于该车超速点的测速器
answers/GD-S02292/detect/detect.cpp:93: else//该车加速运动(从加速点到结束都超速)
answers/GD-S02292/detect/detect.cpp:97: car[i].lp=erfen_dayudengyu(chaosudian);//找第一个大于等于该车超速点+1的测速器
answers/GD-S02292/detect/detect.cpp:98: car[i].rp=m;//最后一个测到该车的测速器
answers/GD-S02292/detect/detect.cpp:104: //完了第二问不会第一问还打了那么多呜呜呜
answers/GD-S02457/detect/detect.cpp:37: //多测清空！！！
answers/GD-S02457/detect/detect.cpp:100: ans2++;//假贪心
answers/GD-S01727/detect/detect.cpp:99: lu[p[m-1]]=p[m-1]+1;//记住特判超速路段于最后一个检测仪结束的情况
answers/GD-S02121/detect/detect.cpp:32: clj[temp]=i;//clj[位置]链接到北方最近的检查点
answers/GD-S00051/detect/detect.cpp:18: while(t--){//多测清空！
answers/GD-S00051/duel/duel.cpp:25: num[a[i]]-=n-now;//全用了
answers/GD-S00051/color/color.cpp:11: if(vis[i]==vis[j]){//左侧最近同色
answers/GD-S00051/color/color.cpp:12: if(a[i]==a[j])s+=a[i];//同数
answers/GD-S00662/detect/detect.cpp:5:bool vis[N];//记录路灯是否被打开
answers/GD-S00662/detect/detect.cpp:6:int n,m,L,V,p[N],road[N];//记录路上何处有路灯
answers/GD-S00662/detect/detect.cpp:65: //检测可关闭数量
answers/GD-S02559/arena/arena.cpp:12:网上常有句略带自嘲意味的笑谈：“你区区数十年的努力，凭什么比得上人家‘奋六世之余烈’的积累？”
answers/GD-S02559/arena/arena.cpp:13:刘子超出生后十多年这句话才出现，但他并不当回事：
answers/GD-S02559/arena/arena.cpp:14:“当然，别人的积累我怎敢企及？我不过是余烈罢了。”
answers/GD-S02559/arena/arena.cpp:16:第一章 爬
answers/GD-S02559/arena/arena.cpp:17:古人云：“不孝有三，无后为大。”这句话的起源笔者也尚不知晓，只是知道从传统意义上来说，有了个男孩便算是便是摘掉了“不孝”中最大的那顶帽子，可以叫人舒一口气了。
answers/GD-S02559/arena/arena.cpp:18:刘东也这么觉得。虽然高低是读过几本书，家学也称得上是有点渊源——祖上每隔几代就会出一位能混出点名堂的人物——但还是对自家血脉的降世感到由衷的幸福：这到才有些明白“父爱”的沉重了。
answers/GD-S02559/arena/arena.cpp:19:看着旁边脸色苍白却还是挤出微笑的妻子，刘东翻开族谱，准备从祖先那里汲取些取名的灵感。只见扉页上大大写着几个字：家传五代复辈“子”。刘东算算，这恰是第五代了。
answers/GD-S02559/arena/arena.cpp:20:照理来说，辈分这种象征家族传承的东西，是不会出现如此离谱的情况的。说来也奇怪，不知是哪位先祖，把夹在每一个“子”辈中间的字都安排的明明白白， 却是硬塞了个“子”字。后辈却也没有提出什么异议，因为每一个“子”字辈总能出些人物，能为家族带来些辉煌。
answers/GD-S02559/arena/arena.cpp:21:“祖上大约是有位行军旅的人物，”刘东兴致勃勃地对妻子说，“‘五’，应该取自于‘伍’。你知道吗，战国时期为了被充分利用、犁出大量沟壑的土地上战斗，常将五辆车上的士兵并为三伍，那时候一车为三人……”
answers/GD-S02559/arena/arena.cpp:22:妻子目光有些无奈。
answers/GD-S02559/arena/arena.cpp:23:“那就取战国名将马超的名作为孩子的名字吧！”刘东决定。
answers/GD-S02559/arena/arena.cpp:24:妻子叹了口气：“你的书真是还给老师了，‘战国名将马超’这种话都说的出来。”
answers/GD-S02559/arena/arena.cpp:25:刘东才意识到不对，但也不准备做出什么更改了：“就这样决定吧，孩子叫‘刘子超’！”
answers/GD-S02559/arena/arena.cpp:27:不同的地方有不同的说法，但至少在刘子超的家乡，老话是这么讲的：“三月能爬，七月能站，十月能走。”
answers/GD-S02559/arena/arena.cpp:28:能爬了，代表小脑平衡中枢有所发育，那按理来讲大脑也高低能长点。
answers/GD-S02559/arena/arena.cpp:29:也就是出生三个月后，刘子超才慢慢有些间断的清醒意识，等他不知那次清醒，百日宴到了。
answers/GD-S02559/arena/arena.cpp:30:“瞧瞧，刘家的小伙子长得真秀气，长大后准是个状元！”
answers/GD-S02559/arena/arena.cpp:31:“哟，三个月差不多能爬了吧，小刘，子超能爬了没？”
answers/GD-S02559/arena/arena.cpp:32:“好可爱的小弟弟！”
answers/GD-S02559/arena/arena.cpp:33:“嘿嘿，才三个月大的小正太，好像当成橡皮糖捏（嘶溜”
answers/GD-S02559/arena/arena.cpp:34:才出生三个月就听到这么离谱的话，刘子超顿时乱了阵脚。
answers/GD-S02559/arena/arena.cpp:35:“没道理，没可能的啊！办酒是满月的事情，怎么我一个月就有意识了？！这是多少年了也不知道，但上次临死前还听闻过洋人搞出了些所谓chemistry的东西，难道还有这功效？”
answers/GD-S02559/arena/arena.cpp:36:还没来得及胡思乱想，刘子超就被一把抓住，放到了抓周的桌子上。
answers/GD-S02559/arena/arena.cpp:37:所幸，这个他熟。
answers/GD-S02559/arena/arena.cpp:38:书，算盘，笔，马鞭，这都是过去常见的玩意。但边上还有些个直角连长管的，方块又不像砖的，黑不溜秋像老鼠的，又是些什么玩意？
answers/GD-S02559/arena/arena.cpp:39:不对，那妹妹我见过的，是火铳，洋人叫gun的……妹妹个鬼啊！这东西怎么敢拿给小孩子的！
answers/GD-S02559/arena/arena.cpp:40:刘子超环顾了一下。一般来说，拿书是最保险的，这玩意最让父母开心，但是也有被父母强迫着在家里面死读书的风险；这种时候假如又为了摆脱而表现的有所天资的话，那就不得了了：父母会把你视作家族的希望，望子成龙，不考个状元回来不罢休。
answers/GD-S02559/arena/arena.cpp:41:读者应该没在历史上见到过名叫“刘子某”的状元。当然，刘子超没考到过状元，可即便是他不到二十岁就中了举，父母依旧不算满意，认为中举的人祖辈也有过，而像他这样的人生来就是要拔高家族的上限的。
answers/GD-S02559/arena/arena.cpp:42:于是他又多读了几年，而常年的苦读让他不知多久以前从《周易》里学的养生之法也派不上用场——古人的确有些玄乎到今人难以理解的东西，但那只是世界给人类当代科学变的小魔术，而不是自然想毁灭人类根基而施的魔法。于是他三十多岁就离开了人世。
answers/GD-S02559/arena/arena.cpp:43:总之，刘子超决定找点新奇玩意，一把抓住那黑不溜秋的东西。
answers/GD-S02559/arena/arena.cpp:44:一片嘈杂声中，刘子超听清了这东西的名字：鼠标。
answers/GD-S02559/arena/arena.cpp:46:往后的几个月，刘子超一直在整理自己的记忆。
answers/GD-S02559/arena/arena.cpp:47:读者应该也看出来了：刘子超是个网文里并不少见的“穿越者”。
answers/GD-S02559/arena/arena.cpp:48:说是穿越有点高估主人公了，这事情说难听点叫借尸还魂——借后辈的身体还先祖的魂。
answers/GD-S02559/arena/arena.cpp:49:没时间写了。
answers/GD-S00174/color/color.cpp:5:int b[N];//1代表红色，2代表蓝色
answers/GD-S01113/detect/detect.cpp:55: if (c[ov[i]].a < 0 && mxdw == 0) mxdw = ov[i]; //最远的 a<0
answers/GD-S01113/detect/detect.cpp:58: //最远的测速限制条件
answers/GD-S01902/color/color.cpp:5://d[i][j][k][l] 表示 前 i 个数 ，左边最靠近的与此处颜色不同的数的数值为 j
answers/GD-S01902/color/color.cpp:6:// k=0 表示前此处为红色， k=1 表示此处为蓝色
answers/GD-S00320/color/color.cpp:22: //记得删注释
answers/GD-S00320/color/color.cpp:32://貌似是状压DP，我们没救了
answers/GD-S00320/arena/arena.cpp:6: //记得删注释
answers/GD-S00217/detect/detect.cpp:69: if(double(q+a[i].d)>L) a[i].safe=1; //超速时已出主干道
answers/GD-S00217/detect/detect.cpp:73: a[i].pos.second=L; //超速路段在中间到末尾
answers/GD-S00217/detect/detect.cpp:78: else{ //一开始超速
answers/GD-S00217/detect/detect.cpp:79: if(a[i].a0>=0){ //无法减速
answers/GD-S00217/detect/detect.cpp:85: else{ //减速时
answers/GD-S00217/detect/detect.cpp:87: if(q+a[i].d>L){ //无法在终点前减速
answers/GD-S00217/detect/detect.cpp:93: else{ //在终点前减速
answers/GD-S02767/detect/detect.cpp:18: int n, m, L, V; // 车数，测速仪数，道路长度，限速
answers/GD-S02767/detect/detect.cpp:20: // bool vis[Long]{}; // 表示路程为i时有无车超速
answers/GD-S02767/detect/detect.cpp:21: int sum = 0, up = -1, cnt = 0; // 超速车数量，最晚超速的路程值，可移除的测速仪数
answers/GD-S02767/detect/detect.cpp:24: // 驶入时的路程值d，初速度v，加速度a
answers/GD-S02767/duel/duel.cpp:36: if (tmp == num[i].first) { // 攻击值相同，不影响结果
answers/GD-S02767/duel/duel.cpp:38: }else { // 攻击值不同，说明还能继续游戏
answers/GD-S02767/duel/duel.cpp:49: vector <pair<int, bool>> newnum(n); // 攻击值和是否攻击过
answers/GD-S02767/duel/duel.cpp:56: bool flag = 1;// new中存老数据
answers/GD-S02767/duel/duel.cpp:114: stack <int> zhan; // 攻击力，剩余数量
answers/GD-S01598/detect/detect.cpp:10://判断是否超速，超速为开始超速的距离,不超速-1
answers/GD-S01648/detect/detect.cpp:22:}dier[100005];//第二个问题
answers/GD-S01648/detect/detect.cpp:154: int jss=0;//为下文计数
answers/GD-S01982/arena/arena.cpp:86:浼板垎 100+40+20+16=176锛屽瘎
answers/GD-S01982/arena/arena.cpp:90:鍘熺锛屽惎鍔紒
answers/GD-S02553/detect/detect.cpp:3:int c[1000005],cc[100005],d[100005],cv[100005],a[100005];//汽车从最南端的d处驶入，以cv的初速度和a的加速度向北行驶，c为检测仪
answers/GD-S02553/detect/detect.cpp:16: scanf("%d %d %d %d",&n,&m,&l,&v);//n为汽车数量，m为测速仪数量，l为主干道长度，v为道路限速
answers/GD-S02553/color/color.cpp:1://不够时间，摆了
answers/GD-S02553/arena/arena.cpp:1://没时间写，摆了
answers/GD-S02350/detect/detect.cpp:44: //初始化
answers/GD-S02350/detect/detect.cpp:56: //前置
answers/GD-S01702/detect/detect.cpp:14:bool check(int x,int k){//检测 k 这辆车在第 x 个摄像头有没有超速
answers/GD-S01702/detect/detect.cpp:72: c[i].t=ans;//超速直到第 t个摄像头之后
answers/GD-S01702/detect/detect.cpp:84: c[i].t=ans;//第 t个摄像头之后超速
answers/GD-S00465/detect/detect.cpp:4://已知某车（一共k车）在第i个点（一共n点）超速，求n最少)
answers/GD-S02272/detect/detect.cpp:26:bool check(int i) { //第k辆车是否超速
answers/GD-S02272/detect/detect.cpp:28: //初始位置 初速度 加速度
answers/GD-S02272/detect/detect.cpp:29: if(!ai) { //如果是匀直运动
answers/GD-S02272/detect/detect.cpp:32: }else if(ai > 0) { //如果是匀加直
answers/GD-S02272/detect/detect.cpp:33: if(v0 > v && d <= c[m]) return 1; //一开始就超速
answers/GD-S02272/detect/detect.cpp:37: }else { //如果是匀减直
answers/GD-S02272/detect/detect.cpp:40: int fir = upper_bound(c + 1 , c + 1 + m , x) - c - 1; //右端点
answers/GD-S02272/detect/detect.cpp:54:node jsk(int i) { //确定区间
answers/GD-S02272/detect/detect.cpp:56: //初始位置 初速度 加速度
answers/GD-S02272/detect/detect.cpp:57: if(!ai) { //如果是匀直运动
answers/GD-S02272/detect/detect.cpp:60: }else if(ai > 0) { //如果是匀加直
answers/GD-S02272/detect/detect.cpp:64: }else { //如果是匀减直
answers/GD-S02272/detect/detect.cpp:74: //当超速时
answers/GD-S02272/detect/detect.cpp:75: b[++ans1] = jsk(i); //确定区间
answers/GD-S00287/color/color.cpp:5://模拟赛全是染色，到了考场不会染色了哈哈哈哈
answers/GD-S00287/arena/arena.cpp:4://高三牲的最后一次OI了，awa让我进一次NOIP吧qwq
answers/GD-S00287/arena/arena.cpp:5://不然高三的生活真的是受不了的啊awa
answers/GD-S03028/detect/detect.cpp:27: sort(p+1,p+1+m);//从小到大排序
answers/GD-S00321/detect/detect.cpp:39:如果T1挂了，那就要AFO了
answers/GD-S00321/color/color.cpp:45:如果T1挂了，那就要AFO了
answers/GD-S00449/detect/detect.cpp:11:int sum[1000009];//区间内测速仪数量
answers/GD-S00449/detect/detect.cpp:48: if(tag1)//加速度全为零
answers/GD-S00449/detect/detect.cpp:65: else if(tag2)//加速度全为正
answers/GD-S00449/detect/detect.cpp:93: else if(tag3)//加速度全为负
answers/GD-S00449/duel/duel.cpp:6:int tag[100009];//表示每一群个数
answers/GD-S01034/color/color.cpp:5:int n, ans, T, c[maxn], a[maxn], f[maxn]; //0表示红，1表示蓝
answers/GD-S01942/detect/detect.cpp:15:bool ll[N],rr[N];//为0表示开区间 为1表示闭区间
answers/GD-S00889/detect/detect.cpp:1://对每辆会超速的车,可以检测到它超速的测速仪在一个测速仪编号为[csy(di),j]或[j,m]的区间中
answers/GD-S00889/detect/detect.cpp:2://(csy(d)表示距离最南端距离为d的位置后最近的测速仪编号,可以二分求)
answers/GD-S00889/detect/detect.cpp:3://所以题意转化为给定最多n个区间,求最少选多少个数,使每个区间中都有至少一个数
answers/GD-S00889/detect/detect.cpp:4://按区间右端点排序,然后贪心即可
answers/GD-S00889/color/color.cpp:9://////dp[i][0/1]:设当前填到j,同下
answers/GD-S00889/color/color.cpp:10://////dp[i][j][0/1]:给前i个数染了色,第i个数是红/蓝,上一个蓝/红色的数为a[j]
answers/GD-S00889/color/color.cpp:12://////lst[i]:最大的j<i使a[j]=a[i]
answers/GD-S00889/color/color.cpp:13://////nxt[i]:最小的j>i使a[j]=a[i]
answers/GD-S00889/color/color.cpp:45://// for(int j=1;j<i-1;j++){ //改用线段树维护
answers/GD-S02485/detect/detect.cpp:4://l：主干道长度，v：限速，d[i]：车初始位置，v[i]：初速度，a[i]：加速度
answers/GD-S02485/detect/detect.cpp:6: int q;//p[i].q：测速器位置
answers/GD-S02485/detect/detect.cpp:32: di=d[i]+(vn*vn-v[i]*v[i]*1.0)/(2*a[i]*1.0);//开始超速的位置
answers/GD-S02485/detect/detect.cpp:41: di=d[i]+(vn*vn-v[i]*v[i]*1.0)/(2*a[i]*1.0);//结束超速的位置
answers/GD-S02485/detect/detect.cpp:52://v1=v0 + a*t t时刻后的速度
answers/GD-S02485/detect/detect.cpp:53://s =v0*t + 0.5*a*t^2 t时刻后行驶路程
answers/GD-S02485/detect/detect.cpp:54://v=sqrt(v0^2 + 2*a*s) 行驶路程为s时瞬时速度
answers/GD-S00502/detect/detect.cpp:11: if(zz==0) //匀速行驶
answers/GD-S00502/detect/detect.cpp:19: else if(zz>0) //匀加速行驶
answers/GD-S00502/detect/detect.cpp:29: else if(zz<0)//匀减速行驶
answers/GD-S00502/duel/duel.cpp:6:int n,a[100010],b[100010],c[100010]; //a[]表示血量和防御力,b[]用来记录是否攻击过，c用来记录是否生存
answers/GD-S00502/duel/duel.cpp:25: c[i]=-1; //i淘汰了
answers/GD-S02898/detect/detect.cpp:6:bool f[1000010];//有无测速仪
answers/GD-S02898/detect/detect.cpp:7:long long pcnt[1000010];//位于第i个点的测速仪（没有为-1）可以拦截下多少车
answers/GD-S02898/detect/detect.cpp:33: break;//驶离主干道
answers/GD-S02898/detect/detect.cpp:41: cnt++;//超速车辆
answers/GD-S02898/duel/duel.cpp:6://0表示未攻击、没死
answers/GD-S02898/duel/duel.cpp:7://1表示攻击了、没死
answers/GD-S02898/duel/duel.cpp:8://2表示死了
answers/GD-S02898/duel/duel.cpp:13: //有人还没攻击，游戏还未结束
answers/GD-S02898/duel/duel.cpp:37: continue;//已经出击过了
answers/GD-S02898/duel/duel.cpp:40: //找自己的对手
answers/GD-S02898/duel/duel.cpp:75: // ↑1的被2的kill的那些
answers/GD-S02898/duel/duel.cpp:78: //1的被2的杀光光
answers/GD-S00167/detect/detect.cpp:18:double came[1000551];// 记录该摄像头有没有拍照
answers/GD-S00167/color/color.cpp:24: // 记录两种颜色上一项是什么
answers/GD-S00578/detect/detect.cpp:31:int binary_search1(int l,int r,int dev){ //向上取整
answers/GD-S00578/detect/detect.cpp:44:int binary_search2(int l,int r,int x){ //向上取整
answers/GD-S00578/color/color.cpp:10:stack<int> q1; //红色(存储大数)
answers/GD-S00578/color/color.cpp:11:stack<int> q2; //蓝色
answers/GD-S00876/detect/detect.cpp:23:// if(-v0*v0>=2*a*x) return 0; //减速到0
answers/GD-S00876/arena/arena.cpp:20:void dfs(int ndep,int len) {//根据当前情况将ans填满，注意：ans中记录编号
answers/GD-S00876/arena/arena.cpp:48:void Sol2() {//枚举不知道的，钦定1个为100，其他为0
answers/GD-S02494/detect/detect.cpp:53: }//初始化
answers/GD-S02494/duel/duel.cpp:25: if (a[i] == -1 || b[i] == false)continue;//如果没了，直接跳过
answers/GD-S02494/duel/duel.cpp:34: } //将小于a[i]的数插入c中
answers/GD-S02494/duel/duel.cpp:35: if (c[0][max()] == 0 && c[1][max()] == 0)continue;//如果没有直接跳过
answers/GD-S02494/color/color.cpp:14: if (num == n) {//判断
answers/GD-S02494/color/color.cpp:19: //递归
answers/GD-S02494/color/color.cpp:27: a[1][num] = 1; //染色
answers/GD-S02494/color/color.cpp:35: a[1][num] = 0;//染回去
answers/GD-S00310/detect/detect.cpp:10:double get_v1(double s,long long v,long long a)//初速度v加速度a
answers/GD-S01704/detect/detect.cpp:15: //多测要清空！！！！！！
answers/GD-S01525/detect/detect.cpp:14: int q[105][105];//与p对应，01测速仪
answers/GD-S01525/detect/detect.cpp:30: if (car[j].vi > V){//全程超速 ,只有这种情况会超速
answers/GD-S01525/detect/detect.cpp:44: if(car[j].vi>V){//如果初始速度大与上面同理
answers/GD-S01525/detect/detect.cpp:56: }else if (car[j].vi == V){//非重合与上面同理
answers/GD-S01525/detect/detect.cpp:68: }else if(car[j].vi < V){//1.直至终点都没超速；2中途就超速
answers/GD-S01525/detect/detect.cpp:84: }else if(car[j].ai<0){//1.初速度大；2.初速度等
answers/GD-S02839/detect/detect.cpp:9:int lft[L],rgt[L]; //距离i号点最近的测速仪编号
answers/GD-S02839/detect/detect.cpp:10:int ld[N],rd[N]; //i号车会被[ld[i],rd[i]]的摄像头拍到
answers/GD-S02839/detect/detect.cpp:11:int id,g[N]; //所有会被拍到的车的集合按右端点升序排列
answers/GD-S02839/color/color.cpp:6:int t,n,a[N],f[N],tot,ans; //0为红色，1为蓝色
answers/GD-S02839/color/color.cpp:7:int n1,n2,h[N],b[N]; //红色数序列，蓝色数序列
answers/GD-S02839/arena/arena.cpp:11:int f[N][20]; //每一轮的胜者
answers/GD-S01363/detect/detect.cpp:22:int t[2000005]; //向右偏移1
answers/GD-S01363/detect/detect.cpp:28:int Query(int x){ // 查询[x , y]: Query(x + 1) - Query(y)
answers/GD-S02777/detect/detect.cpp:17: v_now=完蛋了我忘了开方的那个函数怎么写了QAQ便捷点的暴力爆不了了QAQ(pow(c[N].v,2))+(2*c[N].a*(i-D));
answers/GD-S02777/detect/detect.cpp:93: // cout<<M_in[i]<<"处的测速仪是可以关掉的测速仪" <<endl;
answers/GD-S02777/detect/detect.cpp:119:样例2：（人工制作）
answers/GD-S02777/duel/duel.cpp:12: // cout<<"当i="<<i<<"时，此时的值为"<<R[i]<<endl;
answers/GD-S02777/duel/duel.cpp:17: // cout<<"当j="<<j<<"时，此时的值为"<<R[j];
answers/GD-S02777/duel/duel.cpp:24: // cout<<" i可以杀j"<<endl;
answers/GD-S02777/duel/duel.cpp:29: // cout<<" i无法杀j"<<endl;;
answers/GD-S01880/duel/duel.cpp:4:int r[100050],ri[100050],tong[100050],rx,cnt=0,ans;//cnt攻击过，ans剩余
answers/GD-S01880/duel/duel.cpp:16: ri[r[i]]++;//战斗力为r[i]的个数
answers/GD-S02307/detect/detect.cpp:18:bool jis(int h,int j)//是否超速
answers/GD-S02484/duel/duel.cpp:35:未退出游戏的最小值==n-退出游戏的最大值(maxx)即尽可能的使大的数去打小的数
answers/GD-S01234/detect/detect.cpp:11: int l,r;//表示l~r超速
answers/GD-S02989/detect/detect.cpp:10://计算超速的区间
answers/GD-S02989/detect/detect.cpp:93:v0初速度 v1在t时刻后的速度
answers/GD-S02989/detect/detect.cpp:94:v2瞬时速度 a加速度 t时间 s位移
answers/GD-S01076/detect/detect.cpp:17: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/detect/detect.cpp:18: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/detect/detect.cpp:19: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/detect/detect.cpp:20: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/detect/detect.cpp:21: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/arena/arena.cpp:9: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/arena/arena.cpp:10: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/arena/arena.cpp:11: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/arena/arena.cpp:12: //当然小 S 觉得这个问题还是太简单了
answers/GD-S01076/arena/arena.cpp:13: //当然小 S 觉得这个问题还是太简单了
answers/GD-S02108/color/color.cpp:6://DFS初始参数：1 -1 -1 0
answers/GD-S02959/duel/duel.cpp:115: //cout<<"i下标："<<i<<"j下标："<<j<<"状态:"<<arr[j].ifs<<"打击："<<arr[j].r<<"->"<<arr[i].r<<"\n";
answers/GD-S02235/duel/duel.cpp:6://r1[i]表示攻击力为i的怪兽还有几只能攻击 ，r2[i]表示还有几只攻击力为i的怪兽
answers/GD-S02235/duel/duel.cpp:39://复杂度(最坏情况下) = O(N + M ^ 2 + M) = O(M^2) , M最大为1e5
answers/GD-S00481/detect/detect.cpp:6:// 记得清空数组
answers/GD-S00481/detect/detect.cpp:7:// 记得处理好 a < 0，同时使出点在 L 前的 cases
answers/GD-S00481/detect/detect.cpp:36: // 后面没有其他的测速站点了
answers/GD-S00481/detect/detect.cpp:40: // 如果不会超速，就 continue
answers/GD-S00481/detect/detect.cpp:84: // 找最后一个可以检查到的摄像头
answers/GD-S00481/arena/arena.cpp:16: // 前 p 个元素
answers/GD-S03123/detect/detect.cpp:30: Step 1 最大即为P[m]
answers/GD-S03123/detect/detect.cpp:33: 若超速 且 小于p max 则统计
answers/GD-S03123/detect/detect.cpp:35: 超速车辆为0 M sum = 0
answers/GD-S03123/detect/detect.cpp:51: 对于每一个车 取每个测速仪位置 进行瞬时速度测量 统计超速车辆
answers/GD-S03123/detect/detect.cpp:52: 另外的对于 a[i] < 0 的车辆统计其最远行驶距离
answers/GD-S03123/detect/detect.cpp:53: 复杂度 O(nm)
answers/GD-S03123/detect/detect.cpp:55: 状态压缩 对于测速仪进行取舍
answers/GD-S03123/detect/detect.cpp:56: 考虑对于每一个超速的车 其超速与否状态是否改变
answers/GD-S03123/detect/detect.cpp:57: 其次 提前记录好用vis记录是否超速即可
answers/GD-S03123/detect/detect.cpp:58: 对每一个符合要求的状态取最小
answers/GD-S03123/detect/detect.cpp:59: 复杂度 O(2^m*m*n)
answers/GD-S03123/detect/detect.cpp:68: if(d[i]<=p[j] && dis[i]>=p[j]){//进入位置小于测速仪距离 且 最远行驶距离必须大于测速仪
answers/GD-S03123/detect/detect.cpp:69: double v_=sqrt(1.0*v[i]*v[i]+(p[j]-d[i])*a[i]*2.0);//即在测速仪下的速度
answers/GD-S03123/detect/detect.cpp:75: //超速即可退出
answers/GD-S03123/detect/detect.cpp:81: for(int i=0;i<(1<<m);i++){//特殊的0为选中为了方便统计
answers/GD-S03123/detect/detect.cpp:82: int ks=1;//对于状态
answers/GD-S03123/detect/detect.cpp:85: int k1=1;//对于第j辆车 判断是否有影响
answers/GD-S03123/detect/detect.cpp:87: if(((i>>(k-1))&1)==0 && d[j]<=p[k] && dis[j]>=p[k]){//已被选取
answers/GD-S03123/detect/detect.cpp:88: double v_=sqrt(1.0*v[j]*v[j]+(p[k]-d[j])*a[j]*2.0);//即在测速仪下的速度
answers/GD-S03123/detect/detect.cpp:92: //超速即可退出 说明不会改变
answers/GD-S03123/detect/detect.cpp:99: //此状态不可取
answers/GD-S03123/detect/detect.cpp:103: if(ks){//可取 ->统计关闭的数量
answers/GD-S03123/color/color.cpp:21: if(((i>>(j-1))&1) == 0 ) val=0;//当前为 蓝色 0
answers/GD-S03123/color/color.cpp:22: if(((i>>(j-1))&1) == 1 ) val=1;//当前为 红色 1
answers/GD-S03123/color/color.cpp:25: if((status&1)==val) // 当前相同 -> 记录
answers/GD-S03394/detect/detect.cpp:1:#include<bits/stdc++.h>//《对于加速度并不熟悉》
answers/GD-S03394/detect/detect.cpp:2:using namespace std;//祝贺,本题不需要long long
answers/GD-S03394/detect/detect.cpp:3:const int MAXN=1e6+7;//大修之后变成了要么就几个点的ans2不对,要么超时,要么全出事儿
answers/GD-S03394/detect/detect.cpp:4:const int inf=3e6+7;//对于不可能被检测到的车辆,将其s1,s2设置为不可用的值
answers/GD-S03394/detect/detect.cpp:7:int s1[MAXN],s2[MAXN];//该车开始/结束超速的位置
answers/GD-S03394/detect/detect.cpp:8:int cnt[MAXN];//确认此测速器被使用的次数
answers/GD-S03394/detect/detect.cpp:11:int check(int lef,int rig){//...合着二分在这个位置又跑出来了吗
answers/GD-S03394/detect/detect.cpp:12: int l=1,r=m,mid,ans=0;//在排过序的p里面二分
answers/GD-S03394/detect/detect.cpp:17: else{//在我们需要的区间内
answers/GD-S03394/detect/detect.cpp:18: if(p[mid-1]>=lef)r=mid-1,ans=r;//需要确认第一个测速器位置
answers/GD-S03394/detect/detect.cpp:43: if(a[i]<=0)s1[i]=inf;//不可能超速
answers/GD-S03394/detect/detect.cpp:44: else{//存在超速可能性
answers/GD-S03394/detect/detect.cpp:46: s1[i]=d[i]+(x/(a[i]*2))+1;//如果除不尽,那么视为+1.比方说在5.5进入超速(==V),那么测速器最少该在6检测;如果在6进入超速(==V),那么实际上到下一个位置才>V,真正超速
answers/GD-S03394/detect/detect.cpp:47: if(s1[i]>L)s1[i]=inf;//出去之后才超速就不用理会了
answers/GD-S03394/detect/detect.cpp:49: s2[i]=inf;//本车不存在结束超速的位置
answers/GD-S03394/detect/detect.cpp:51: else if(v[i]>V){//进来就超速
answers/GD-S03394/detect/detect.cpp:52: if(a[i]>=0)s2[i]=L;//一直De javu
answers/GD-S03394/detect/detect.cpp:55: if(x%(2*(-a[i]))!=0){//比如说如果到达4.4时退出超速,那么最后的测速器只能在4
answers/GD-S03394/detect/detect.cpp:56: s2[i]=d[i]+(x/(-a[i]*2));//注意负号!!!
answers/GD-S03394/detect/detect.cpp:59: s2[i]=d[i]+(x/(-a[i]*2))-1;//同理,如果正好在7退出超速(==V),只能查看前一个位置
answers/GD-S03394/detect/detect.cpp:61: if(s2[i]>L)s2[i]=L+1;//如果后面一直超速,直接设定为L+1缩小一下范围
answers/GD-S03394/detect/detect.cpp:62: if(s2[i]<d[i])s2[i]=d[i];//这里是>V但是仍然在下个位置前就退出了超速,导致s2<d[i],因此对其特判
answers/GD-S03394/detect/detect.cpp:64: s1[i]=inf;//本车不存在进入超速的位置(进来就超速直接看s2就好了)
answers/GD-S03394/detect/detect.cpp:66: else{//保险一点...
answers/GD-S03394/detect/detect.cpp:67: if(a[i]>0){//马上就超速
answers/GD-S03394/detect/detect.cpp:70: else{//不会超速了
answers/GD-S03394/detect/detect.cpp:76: sort(p+1,p+m+1);//必须让测试仪按照位置顺序...
answers/GD-S03394/detect/detect.cpp:78: if(s1[i]!=inf&&s2[i]==inf){//若此辆车过一会儿会超速
answers/GD-S03394/detect/detect.cpp:79: nowp[i]=check(s1[i],L);//判断后面有没有测速器在线抓拍
answers/GD-S03394/detect/detect.cpp:82: for(int j=nowp[i];j<=m;++j){//这块可以拿二分优化,但是没时间了:(
answers/GD-S03394/detect/detect.cpp:89: else if(s1[i]==inf&&s2[i]!=inf){//若此车过一会儿会退出超速
answers/GD-S03394/detect/detect.cpp:101: for(int i=1;i<=n;++i){//估计还是这里有问题...但是修不动了
answers/GD-S03394/detect/detect.cpp:105: if(vis[j]==1){//有测速仪被固定了,那这边就不用新增了
answers/GD-S03394/detect/detect.cpp:109: if(maxcnt<cnt[j]){//否则优先使用检测到的车最多的测速器
answers/GD-S03394/detect/detect.cpp:116: for(int i=1;i<=m;++i)if(!vis[i])ans2++;//由于是最优策略(?),剩下没用到的就是不需要的
answers/GD-S03394/duel/duel.cpp:1:#include<bits/stdc++.h>//记得把freopen杠回去!!!
answers/GD-S03394/duel/duel.cpp:5:int r;//攻击力等于防御力;攻击力不超过就干不掉
answers/GD-S03394/duel/duel.cpp:8:int main()//希望尽量剩少点
answers/GD-S03394/duel/duel.cpp:23: if(cnt[u]>t){//剩的怪太少
answers/GD-S03394/duel/duel.cpp:25: t=0;//此时前面没有剩余的怪了
answers/GD-S03394/duel/duel.cpp:27: else{//剩的怪足够
answers/GD-S03394/duel/duel.cpp:31: t+=cnt[u];//确认前面有多少剩余的比较逊的怪
answers/GD-S03394/color/color.cpp:6:int f[MAXN][2];//表示到达第i个数时且i染成红(0)/蓝(1)时最大C总和
answers/GD-S03394/color/color.cpp:7:int lt[MAXN][2];//表示到达第i个数时左端最近的染成红/蓝的数
answers/GD-S03394/color/color.cpp:22: f[i][0]=f[i][1]=lt[i][0]=lt[i][1]=0;//毕竟A[i]>=1
answers/GD-S03394/color/color.cpp:24: //for(int i=1;i<=n;++i){//...推不出来了
answers/GD-S03394/color/color.cpp:30: for(int i=1;i<=n;++i){//假设所有的相同数字可以被c记入 尝试骗分
answers/GD-S00326/detect/detect.cpp:10:int find(int l, int r, int *p, int x){//不小于当前值的最小值
answers/GD-S00326/detect/detect.cpp:22:int find2(int l, int r, int p[], int x){//不大于当前值的最大值
answers/GD-S00326/detect/detect.cpp:34:int find3(int l, int r, node p[], int x){//不大于当前值的最大值
answers/GD-S02750/detect/detect.cpp:112: l=upr(s);//在l这个探测器这里会被查到超速
answers/GD-S02750/detect/detect.cpp:114: if(l==-1) continue;//不会被查到超速
answers/GD-S01713/arena/arena.cpp:2://破防了，太难写了，调不出来摆烂了. 这个代码只是存着的，肯定是0pts
answers/GD-S03161/detect/detect.cpp:30://限速仪有1e6个！！！记得开数组！！！
answers/GD-S03161/arena/arena.cpp:12: //d数组要开大
answers/GD-S03401/detect/detect.cpp:5: int d,v,a; // 进入时间，初速度，加速度
answers/GD-S02533/color/color.cpp:8: 闲的慌
answers/GD-S03279/detect/detect.cpp:6: //d:驶入位置 v:初速度 a:加速度
answers/GD-S01134/detect/detect.cpp:14:多测记得清空
answers/GD-S01134/detect/detect.cpp:15:这题应该不需要ll 大错特错，差点见祖宗了..
answers/GD-S01134/color/color.cpp:94: //1很好维护
answers/GD-S01134/color/color.cpp:95: //2需要根据a分类
answers/GD-S01134/arena/arena.cpp:25:void solve_A(){//直接按照题意模拟即可复杂度是对的
answers/GD-S01111/arena/arena.cpp:84:写点小作文吧。
answers/GD-S01111/arena/arena.cpp:85:我也是高二老登了啊。
answers/GD-S01111/arena/arena.cpp:86:刚刚改了 detect 的一点细节，结果过不去 detect5 了。出题人的大样例真良心。
answers/GD-S01111/arena/arena.cpp:87:100+100+100+[16, 40]，最后一题大概是 n^3 的吧，大概能过 ci=2^k 的数据。
answers/GD-S01111/arena/arena.cpp:88:还有 8min。会赢吗。
answers/GD-S01111/arena/arena.cpp:89:烦躁。但愿 noip 也有 T3 这样的一眼题。不过一眼题真的好吗，别最后比拼 T4 暴力写了多少以及前三题有没有挂分。
answers/GD-S01111/arena/arena.cpp:90:好想证明一下自己啊。
answers/GD-S01111/arena/arena.cpp:92:还有回头路吗。
answers/GD-S01111/arena/arena.cpp:93:离考试结束还有六分钟。
answers/GD-S01111/arena/arena.cpp:94:再去检查一次吧。
answers/GD-S01111/arena/arena.cpp:95:该关掉虚拟机了。
answers/GD-S01111/arena/arena.cpp:96:好想写点平时写的那种鲜花，但现在好像写不出来。
answers/GD-S01111/arena/arena.cpp:97:祝我认识的人 rp++ 吧，你们值得有好的结果和未来。
answers/GD-S01111/arena/arena.cpp:98:希望这个赛季还能与熟悉的朋友在一起。
answers/GD-S01111/arena/arena.cpp:99:真想再在 APIO 或者 WC 见一面。
answers/GD-S01111/arena/arena.cpp:100:去年看着倒计时时是心如死灰的吧。初三那年的 NOIP 也是。
answers/GD-S01111/arena/arena.cpp:101:运气好罢了，T3 没有想太远。最后一段时间我都不能冷静思考 T4 了。好像一开始写代码我的脑子就不会想题了。
answers/GD-S01111/arena/arena.cpp:102:别挂分就好。
answers/GD-S01111/arena/arena.cpp:103:如果不甘心，就去努力吧。
answers/GD-S00606/detect/detect.cpp:8: double a;//上距离最南端 di 的位置驶入
answers/GD-S00606/detect/detect.cpp:9: double b;//vi初速度
answers/GD-S00606/detect/detect.cpp:10: double c;//ai加速度
answers/GD-S00137/detect/detect.cpp:7:}bc[M];//并查集
answers/GD-S00137/detect/detect.cpp:10:}f[M];//超速车辆的范围
answers/GD-S00137/detect/detect.cpp:11:int num[M],sum;//超速的车辆
answers/GD-S00137/detect/detect.cpp:15: int o=0;//需要测速仪的数量
answers/GD-S02674/detect/detect.cpp:15:{//多测要清空
answers/GD-S01083/detect/detect.cpp:9: int id;//表示第 i 辆车超速
answers/GD-S01083/detect/detect.cpp:10: int pd;//在 pd 位置被检测
answers/GD-S01083/detect/detect.cpp:11: double lw;//在 lw 位置离开主干
answers/GD-S01083/detect/detect.cpp:25: int cnt=0;//统计超速车辆个数
answers/GD-S01083/detect/detect.cpp:26: int tot=0;//统计不可删去的检测仪的个数
answers/GD-S01083/detect/detect.cpp:121:初始化！！
answers/GD-S02517/detect/detect.cpp:38:// 车辆起始位置 车辆起始速度 车辆加速度 道路限速
answers/GD-S02517/detect/detect.cpp:43: //一直不会超速
answers/GD-S02517/detect/detect.cpp:47: //一直超速
answers/GD-S02517/detect/detect.cpp:53: //一直不会超速
answers/GD-S02517/detect/detect.cpp:57: //减速一段路程后不超速
answers/GD-S02517/detect/detect.cpp:64: //一直超速
answers/GD-S02517/detect/detect.cpp:68: //加速一段路程后超速
answers/GD-S02517/detect/detect.cpp:82:// printf("%d",t); // .zzz 测试快读
answers/GD-S02517/detect/detect.cpp:101: for(int i=1; i<=l; i++){ //前缀和处理限速仪
answers/GD-S02517/detect/detect.cpp:104: //测试限速前缀和 .zzz
answers/GD-S02517/duel/duel.cpp:25: //特判 只有1和2
answers/GD-S02517/color/color.cpp:27: colorr[u] = 1;//红色
answers/GD-S03382/detect/detect.cpp:10:int ans;//统计超速车辆
answers/GD-S03382/duel/duel.cpp:14:int vis[N];//出局标记为2,攻击过标记为1
answers/GD-S03382/duel/duel.cpp:35: flag = true;//有怪兽能攻击就继续
answers/GD-S03382/duel/duel.cpp:50: flag = true;//有怪兽能攻击就继续
answers/GD-S03491/detect/detect.cpp:100://hjbh一把抓住45pts，顷刻炼化！hjbh：“不可以，总司令！”
answers/GD-S00069/detect/detect.cpp:9: int d;//开始位置
answers/GD-S00069/detect/detect.cpp:10: int v;//初始速度
answers/GD-S00069/detect/detect.cpp:11: int a;//加速度
answers/GD-S00069/detect/detect.cpp:76: //cnt1超速车辆数，cnt2最多可关闭摄像头数
answers/GD-S00069/duel/duel.cpp:41: if(x[i] >= sum[i])//如果它所拥有的数>=比他小且未出局的数
answers/GD-S03034/detect/detect.cpp:6:int cs[100005];//测速仪位置
answers/GD-S03034/detect/detect.cpp:7:bool c[100005];//第i辆车是否超速
answers/GD-S02244/detect/detect.cpp:7: int d,v,a; //初始位置 初始速度 加速度
answers/GD-S02244/detect/detect.cpp:9:int det[N]; //测速仪位置
answers/GD-S02244/detect/detect.cpp:10:vector<int> hc; //存放超速车辆的下标
answers/GD-S02244/detect/detect.cpp:16: return a.second < b.second; //按照区间的右端点进行排序
answers/GD-S02244/detect/detect.cpp:28: sort(det+1,det+1+m); //从小到大排序测速仪的位置
answers/GD-S02244/detect/detect.cpp:29: //第一问
answers/GD-S02244/detect/detect.cpp:30: //循环遍历每一辆车
answers/GD-S02244/detect/detect.cpp:33: //如果a为正数，那么判断距离车最远的测速仪是否会判车超速
answers/GD-S02244/detect/detect.cpp:42: far_det = det[m]; //最远的测速仪只会是道路尽头的测速仪
answers/GD-S02244/detect/detect.cpp:45: move = far_det-c[i].d; //用最远测距仪的位置和车的初始位置作差得到位移
answers/GD-S02244/detect/detect.cpp:46: far_speed = sqrt(c[i].v*c[i].v+2*c[i].a*move); //根据公式得到当车子到指定测距仪时的瞬时速度
answers/GD-S02244/detect/detect.cpp:51: }else{ //否则判断距离车最近的测速仪是否会判定超速
answers/GD-S02244/detect/detect.cpp:53: near_det = *lower_bound(det+1,det+1+m,c[i].d); //二分得到距离初始位置最近的测距仪
answers/GD-S02244/detect/detect.cpp:66: //最后输出第一问答案
answers/GD-S02244/detect/detect.cpp:68: //第二问
answers/GD-S02244/detect/detect.cpp:69: //对于a<0的超速车辆，将其瞬间速度刚好达到限速的位置计算出来，检查至少要多少个测速仪才能将所有区间覆盖
answers/GD-S02244/detect/detect.cpp:88: //问题转化为求至少多少个测速仪可以覆盖所有的区间
answers/GD-S02244/detect/detect.cpp:90: //贪心，优先使用距离当前区间右端点最近的测速仪
answers/GD-S02244/detect/detect.cpp:95: int dis = *upper_bound(det+1,det+1+m,cars[i].second); //二分查找
answers/GD-S02244/detect/detect.cpp:109: //输出第二问答案
answers/GD-S00566/duel/duel.cpp:3:int n,r,rr,Max; //r为攻,rr为防
answers/GD-S02702/detect/detect.cpp:7:bool op,opp;//false 小于 true 大于
answers/GD-S01712/detect/detect.cpp:24://我们有远大的理想！
answers/GD-S01712/detect/detect.cpp:25://但是不会吧，今年提高组分数线不会要去到 200+pts 吧
answers/GD-S01712/detect/detect.cpp:26://太恐怖了，T2 都不敢打了
answers/GD-S01712/detect/detect.cpp:27://结论不知道假没假，反正大样例过了
answers/GD-S01712/detect/detect.cpp:28://时间复杂度 O(Tn log L)
answers/GD-S01712/detect/detect.cpp:29://预期得分100
answers/GD-S01712/duel/duel.cpp:22://以昂扬的姿态，在新时代中奋勇前行！
answers/GD-S01712/duel/duel.cpp:23://结论口胡的，大样例过了
answers/GD-S01712/duel/duel.cpp:24://时间复杂度 O(n log n)
answers/GD-S01712/duel/duel.cpp:25://预期得分100
answers/GD-S01712/color/color.cpp:23://旧世界打个落花流水，奴隶们起来，起来！
answers/GD-S01712/color/color.cpp:24://时间复杂度O(T*n*2^n或T*n)
answers/GD-S01712/color/color.cpp:25://预期得分20 + ?
answers/GD-S01712/color/color.cpp:26://不知道挂没挂，n <= 15 的大样例过了
answers/GD-S01712/color/color.cpp:54: //全染上，裁判员 + 交替染，裁判员
answers/GD-S01712/arena/arena.cpp:20://不要说我们一无所有，我们拥有整个世界！
answers/GD-S01712/arena/arena.cpp:21://220+ 真的可以 tg1= 吗？
answers/GD-S01712/arena/arena.cpp:22://按照今年这个难度我是不信能拿的，正常人应该都可以拿到这个分吧
answers/GD-S01712/arena/arena.cpp:23://虽然但是，谨慎相信出题人的大样例
answers/GD-S01712/arena/arena.cpp:24://真被scz说中了，黄绿紫黑？
answers/GD-S02538/color/color.cpp:46://0表示红,1表示蓝
answers/GD-S00531/detect/detect.cpp:10://车辆数量 测速仪数量 主干道长度 道路限速
answers/GD-S00531/detect/detect.cpp:13://初位置 初速度 加速度
answers/GD-S01641/detect/detect.cpp:3:int T,n,m,l,v,max,r,d[100005],v1[100005],a[100005],p[100005];//d表示起始位置，v1表示原速度，a表示做加速运动，p表示测速仪位置
answers/GD-S03397/arena/arena.cpp:79: //可修改
answers/GD-S02380/detect/detect.cpp:8://d:位置，v:初速度，a:加速度
answers/GD-S00541/color/color.cpp:44:// // i 与 i-1同色
answers/GD-S01807/arena/arena.cpp:17:为我的五年竞赛学习之路结束撒花！！！
answers/GD-S00401/detect/detect.cpp:5:int n,m,l,x;//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S00401/detect/detect.cpp:6:int d[N],v[N],a[N];//位置d,初速度,加速度(n个)
answers/GD-S00401/detect/detect.cpp:7:int p[N];//测速仪位置(m个)
answers/GD-S00401/detect/detect.cpp:8:int q[N];//检测到车超速的测速仪
answers/GD-S00401/detect/detect.cpp:21: //先测量超速所在的路段
answers/GD-S00401/detect/detect.cpp:22: //注意qn行m列 ,表示第i个车在第j个
answers/GD-S00401/detect/detect.cpp:27: if(v[i]>x){//全程超速
answers/GD-S00401/detect/detect.cpp:29: if(p[j]>=d[i]){//现在开始检测到
answers/GD-S00401/detect/detect.cpp:37: int to=d[i]+sum;//速度到道路限速时到达地方
answers/GD-S00401/detect/detect.cpp:39: if(v[i]>x){//原超速后不超速
answers/GD-S00401/detect/detect.cpp:48: if(v[i]>x){//全程超速
answers/GD-S00401/detect/detect.cpp:55: }else{//原不超速后超速
answers/GD-S00401/detect/detect.cpp:69: }//变速度距离公式x*x-v*v/(2*a)
answers/GD-S00401/duel/duel.cpp:6:int f[100100],e[100100],yu;//f是还剩下的卡和有攻击力的
answers/GD-S00401/duel/duel.cpp:31: f[c]-=f[b];//c号卡门攻击b号卡剩下的有攻击
answers/GD-S00401/duel/duel.cpp:37: f[c]=0;//c号卡门攻击b号卡剩下的有攻击
answers/GD-S00401/duel/duel.cpp:38: }n-=yu;//减去出局
answers/GD-S00943/detect/detect.cpp:22: Car[i].a =z;//有正有负
answers/GD-S01071/detect/detect.cpp:131: check_slow_down(car[i].d, car[i].v, car[i].a);//记得初始化monitor_id
answers/GD-S01667/detect/detect.cpp:51: for(int i = 1;i<=n;i++)//枚举每一辆车
answers/GD-S01009/detect/detect.cpp:13: // n:车辆数量 m:测速仪数量 l:主干道长度 v:道路限速
answers/GD-S01009/detect/detect.cpp:22: double cpos=0.1*(V*V-v[i]*v[i])/a[i]/2; //超速时的路程
answers/GD-S01009/duel/duel.cpp:4:bool vis[100005]; //true为已被消灭,false为还在场上
answers/GD-S01407/detect/detect.cpp:42:// }//输入车的属性
answers/GD-S01407/detect/detect.cpp:43:// for(int i=1;i<=m;i++){ //输入机器位置
answers/GD-S01407/detect/detect.cpp:46:// for(int i=1;i<=n;i++){//求取每辆车的超速区间
answers/GD-S02155/detect/detect.cpp:5://overSp[i]表示第i辆车的超速位置
answers/GD-S02155/detect/detect.cpp:61: int A1 = 0; //超速车辆的数量
answers/GD-S02155/detect/detect.cpp:66: //已知瞬时速度，求达到瞬时速度时的地点
answers/GD-S02155/detect/detect.cpp:69: if(lst[k].os > V && cam[int(m)] >= lst[k].pos) //一定超速
answers/GD-S02155/detect/detect.cpp:71: else //永远不会超速
answers/GD-S02155/detect/detect.cpp:96:这是什么题目啊？？？？？？？
answers/GD-S02155/color/color.cpp:34: //骗分，跑路
answers/GD-S01244/detect/detect.cpp:1:#include<bits/stdc++.h>//多测清空！！
answers/GD-S03127/arena/arena.cpp:14:策略是显然的。
answers/GD-S03127/arena/arena.cpp:16:首先需要一个dp：子树中的能力值是否能为 [0...R]
answers/GD-S03127/arena/arena.cpp:18:然后考虑做另一个 dp 统计答案类似于“子树中胜者的能力值为 k 的编号和”这样。
answers/GD-S03127/arena/arena.cpp:20:复杂度不对。呃呃呃
answers/GD-S03095/detect/detect.cpp:3:int ans,l,t,p[1000005],d[100005],n,m,car[100005],jp[100000];//car数组记录是否超速；
answers/GD-S03095/color/color.cpp:4:void color(int x,bool o)//1为蓝，0为红
answers/GD-S02146/detect/detect.cpp:9: int n[t+1],m[t+1],L[t+1],V[t+1];//n车辆数量，m测速仪数量L主干道长度V道路限速
answers/GD-S02146/detect/detect.cpp:17: cin>>d[j]>>v[j]>>a[j]; //d指距离，v指初速度，a指加速度
answers/GD-S02146/detect/detect.cpp:21: cin>>p[k]; //p为测速仪的位置
answers/GD-S00376/duel/duel.cpp:3:int a[100010],b[100010];//1未，0已
answers/GD-S02902/detect/detect.cpp:124: // 閬嶅巻q涓嬫墍鏈夊厓绱狅紙vector锛夛紝鑻urr鏄厓绱犵殑瀛愰泦锛屽垯灏嗗厓绱犳洿鏂颁负鍏冪礌涓巆urr鐨勪氦闆嗭紱
answers/GD-S02902/detect/detect.cpp:125: // 鍚﹀垯锛屽皢curr鎻掑叆鍒皅涓幓
answers/GD-S02902/duel/duel.cpp:53: int t = p[i];//褰撳墠鎬墿鐨剅
answers/GD-S03436/detect/detect.cpp:37: if(A || B){ //20~40分 特例A确定 特例B调试ing
answers/GD-S03436/detect/detect.cpp:40: } //vt:超速的车的起点，从小至大
answers/GD-S03436/detect/detect.cpp:70: } //预处理每辆车超速范围 闭合
answers/GD-S03436/detect/detect.cpp:77: } //问题转换：找到p中最少个元素，使得每个fx[i]与fy[i]间都有至少一个
answers/GD-S03436/duel/duel.cpp:30: while(s && it!=mp.begin()){ //能干多少干多少
answers/GD-S03436/duel/duel.cpp:36: //每种兽干场上最小的兽，干到干不动/自己就是最小的为止
answers/GD-S03436/color/color.cpp:10:int dfs(int x, int lb, int lr){ //35分爆搜
answers/GD-S03436/color/color.cpp:13: //涂蓝
answers/GD-S03436/color/color.cpp:15: //涂红
answers/GD-S02154/detect/detect.cpp:24://x:删了x个车
answers/GD-S02154/detect/detect.cpp:77: srch(0);//第一个0:删了0个车
answers/GD-S00699/detect/detect.cpp:166:冷静，混个暴力分就能1=！！
answers/GD-S00699/detect/detect.cpp:167:是一段区间。。。
answers/GD-S00699/detect/detect.cpp:168:慢慢想不着急，4h呢！！
answers/GD-S00699/detect/detect.cpp:169:首先求出每一个区间涉及到的测速仪种类是一段区间。
answers/GD-S00699/detect/detect.cpp:170:首先如果只有一个测速仪涉及到这个区间，那么这个测速仪肯定不能删。
answers/GD-S00699/detect/detect.cpp:171:如果对于区间长度大于 2 的区间，对答案的贡献就是 min(1, sum)。其中 len 是区间的长度，sum 是这段区间内被
answers/GD-S00699/detect/detect.cpp:172:标记的测速仪数量。
answers/GD-S00699/detect/detect.cpp:173:对 1 取 max 是因为，迫不得已要保留一个区间。
answers/GD-S00699/detect/detect.cpp:174:那保留哪一个呢？
answers/GD-S00699/detect/detect.cpp:175:想到，如果保留恰当，那么有很多区间对答案的贡献就变成 0 了。
answers/GD-S00699/detect/detect.cpp:176:可以先将区间内没有必要点的区间拿出来。
answers/GD-S00699/detect/detect.cpp:177:问题变成了求最少多少个点可以覆盖所有的区间。
answers/GD-S00699/detect/detect.cpp:178:感觉好经典啊！！！！
answers/GD-S00699/detect/detect.cpp:179:考虑将区间按左端点排序。就是从小到大插入测速仪。
answers/GD-S00699/detect/detect.cpp:180:考虑当前到了区间 [l,r]，查询 [l,r] 中最大覆盖区间的那个点。然后跳过所有被这个点覆盖的区间，继续做。
answers/GD-S00699/detect/detect.cpp:181:感觉很对！！
answers/GD-S00699/detect/detect.cpp:182:那如何查询这个点有多少个区间被覆盖了呢？也就是每次区间+，查询，可以使用差分。
answers/GD-S00699/detect/detect.cpp:183:如何求一个区间内没有任何一个关键点，每次添加一个关键点，然后区间查询有没有，这个东西就是上面的前缀和。
answers/GD-S00699/detect/detect.cpp:185:如果 a > 0，那么是加速状态。知道末速度，知道初速度，知道加速度，求位移 s。
answers/GD-S00699/detect/detect.cpp:186:使用公式 (v1^2-v0^2) / 2a 得到位移，取个上取整作为左端点，L 作为右端点。
answers/GD-S00699/detect/detect.cpp:187:如果 a < 0，那么先判断是否超速，如果不超速就不管他
answers/GD-S00699/detect/detect.cpp:188:如果超速，取起点为左端点，知道末速度，知道初速度，知道加速度，求位移 s。
answers/GD-S00699/detect/detect.cpp:189:使用公式 (v1^2-v0^2) / 2a 得到位移，取个上取整作为右端点。
answers/GD-S00699/detect/detect.cpp:190:感觉做完了。 ！！ljj 没做出 B 感觉，感觉很厉害，C 应该更简单。
answers/GD-S00699/detect/detect.cpp:191:T 是 20, L 是 1e6，前缀和不行。考虑换一种方法。
answers/GD-S00699/detect/detect.cpp:192:单点加，查询前缀和。直接上树状数组。
answers/GD-S00699/color/color.cpp:47:因为 C_i 的值是根据最大的 j 使得 A_i=A_j 的值。这个值是固定的，我们可以将它求出来，记作 lst_i
answers/GD-S00699/color/color.cpp:48:而且我们发现 (lsti,i) 这段区间的值如果是确定的，那不会受到 a_i 的影响。
answers/GD-S00699/color/color.cpp:49:考虑贪心，并且 C_i 也只跟 i 有关，考虑将 a_i 相同的都染成同色，啊？感觉很对。先打打。
answers/GD-S00699/color/color.cpp:50:不对，是最靠近的同色数，这个是会变的。
answers/GD-S00699/color/color.cpp:52:如果 a_i 想要有贡献，那么就得让 (lsti+1,i-1) 这段区间染成同样的颜色。这个贡献是固定的，怎么求呢？
answers/GD-S00699/color/color.cpp:53:不对。 区间内还有可能会有对前面的贡献。先打 2^n 走人。 n=100 怎么做？
answers/GD-S00215/detect/detect.cpp:12: cin>>d[j]>>v[j]>>a[j];//初始加路程 初速度 加速度
answers/GD-S00215/detect/detect.cpp:14: cin>>p[k]; //监测点位置
answers/GD-S00215/detect/detect.cpp:21: else if (a[j]>0){//匀加条件下
answers/GD-S00215/detect/detect.cpp:26: else if (a[j]<0){//匀减条件下
answers/GD-S00215/duel/duel.cpp:4:int n,a[MAXN],b[MAXN],maxn=-1,ans,minn=999999;//a[]记录伤害 b[]记录是否还活着
answers/GD-S02940/detect/detect.cpp:70: if(v0>v){//全程超速
answers/GD-S02940/detect/detect.cpp:81: }else if(v0==v){//全程不超速
answers/GD-S02940/detect/detect.cpp:105: if(v0>v){//全程超速
answers/GD-S02940/detect/detect.cpp:113: }else if(v0==v){//全程不超速
answers/GD-S02940/detect/detect.cpp:115: }else{//全程不超速
answers/GD-S02940/detect/detect.cpp:130: }else if(v0==v){//全程不超速
answers/GD-S02940/detect/detect.cpp:132: }else{//全程不超速
answers/GD-S03490/detect/detect.cpp:17:int point[MAXN];//point[i]:第i辆车在第point[i]个测速点第一次超速
answers/GD-S02172/arena/arena.cpp:23:而海港已经 不知去向
answers/GD-S02172/arena/arena.cpp:24:此刻他醉倒 在洗浴中心 没有潮汐的梦
answers/GD-S02172/arena/arena.cpp:25:胸口已暮色苍茫
answers/GD-S02172/arena/arena.cpp:27:肥胖的城市 递给他一个
answers/GD-S02172/arena/arena.cpp:28:传统的方法 来克制恐慌
answers/GD-S02172/arena/arena.cpp:29:卖掉武器 风暴喉咙 换取饮食
answers/GD-S02172/arena/arena.cpp:32:停电之后 暂时摆脱了
answers/GD-S02172/arena/arena.cpp:33:坚硬的时刻 倒转的河
answers/GD-S02172/arena/arena.cpp:34:肥胖的城市 驱赶着每一个 不愿沉没的人
answers/GD-S02172/arena/arena.cpp:35:那首疯狂的歌又响起
answers/GD-S02172/arena/arena.cpp:37:电灯熄灭 物换星移 泥牛入海
answers/GD-S02172/arena/arena.cpp:38:黑暗好像 一颗巨石 按在胸口
answers/GD-S02172/arena/arena.cpp:39:独脚大盗 百万富翁 摸爬滚打
answers/GD-S02172/arena/arena.cpp:40:黑暗好像 一颗巨石 按在胸口
answers/GD-S02172/arena/arena.cpp:42:电灯熄灭 物换星移 泥牛入海
answers/GD-S02172/arena/arena.cpp:43:黑暗好像 一颗巨石 按在胸口
answers/GD-S02172/arena/arena.cpp:44:独脚大盗 百万富翁 摸爬滚打
answers/GD-S02172/arena/arena.cpp:45:黑暗好像 一颗巨石 按在胸口
answers/GD-S02172/arena/arena.cpp:47:恋恋天下第一！！
answers/GD-S02526/detect/detect.cpp:27:double xm;//达到最大限速时所处位置
answers/GD-S02713/detect/detect.cpp:16:int finds(int v0,int vt,int ai){//向上取整
answers/GD-S02713/detect/detect.cpp:25:int finds2(int v0,int vt,int ai){//向下取整
answers/GD-S01845/detect/detect.cpp:59: secv=sqrt(cc[i].v*cc[i].v+2*cc[i].a*dis);//瞬时速度
answers/GD-S01489/duel/duel.cpp:18: }//从小到大，每只怪兽决当前场上最小的，如果相等则相当于没决，l一定小于i
answers/GD-S01489/arena/arena.cpp:18: if(d[j][j2]){//c2为擂主
answers/GD-S01489/arena/arena.cpp:22: else{//c1为擂主
answers/GD-S00455/detect/detect.cpp:96:int main() { //多测记得清空
answers/GD-S01766/detect/detect.cpp:15: pd=false;//false:到点前超速 true:到点后超速
answers/GD-S01930/detect/detect.cpp:44: int qicnt = 0;//加速类超速
answers/GD-S01930/detect/detect.cpp:45: int micnt = 0;//匀速类超速
answers/GD-S01930/detect/detect.cpp:46: int sicnt = 0;//减速类超速
answers/GD-S01930/detect/detect.cpp:90: //l[i]表示要取的左边界，r[i]表示要取的右边界
answers/GD-S02378/color/color.cpp:5:先写朴素算法，再写根号分支。
answers/GD-S03381/detect/detect.cpp:82: p[i]=tano;//p[i]指向的是tano这个点
answers/GD-S02728/detect/detect.cpp:7: bool is;//是否能够取到边界
answers/GD-S02728/detect/detect.cpp:12:node css[N],cse[N];//第i辆车在距离最南边css[i]时超速的 在 cse【i】结束
answers/GD-S02728/detect/detect.cpp:13:int qjh[L];//做前缀和用
answers/GD-S02728/detect/detect.cpp:15:int findi(int x){//查找第一个 小于等于的位置
answers/GD-S02728/detect/detect.cpp:26:int findx(int x){//查找第一个 大于等于的位置
answers/GD-S03033/detect/detect.cpp:8:// 瓒呴€熻褰曚华鍜屾墍鏈夊姞閫熷害涓鸿礋鐨勮秴閫熻褰曚华鏈夐噸鍚堬紝
answers/GD-S03033/detect/detect.cpp:12:// 鎴戝緢钂伙紒
answers/GD-S03033/detect/detect.cpp:59:// 锛燂紵锛熷垰鍒氱寽鍑烘潵浜嗚櫄鎷熸満鐨勭敤鎴峰瘑鐮佹槸 123456锛岃繖涔堝帀瀹筹紵锛燂紒
answers/GD-S03033/detect/detect.cpp:60:// sudo -i 杈撲釜 123456 灞呯劧鎴愬姛浜嗭紵
answers/GD-S03033/detect/detect.cpp:64:// 鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鍦ㄦ渶鏃╁湪
answers/GD-S03033/detect/detect.cpp:65:// 鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷櫧灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鑷皧鑷矗鑷嚜灏婅嚜璐ｈ嚜鍦ㄦ渶鏃╁湪
answers/GD-S03033/detect/detect.cpp:76: // 鍒€鍏変笌鍓戝奖浜ら敊
answers/GD-S03033/detect/detect.cpp:78: // 鐢熸鏃犺瘽
answers/GD-S03033/detect/detect.cpp:96: // 鍒€鍏変笌鍓戝奖浜ら敊
answers/GD-S03033/detect/detect.cpp:98: // 鐢熸鏃犺瘽
answers/GD-S03033/detect/detect.cpp:151: // v^2+2ap 鏈€澶氭槸 1000000 + 2000000000 = 2001000000 < INT_MAX...
answers/GD-S03033/detect/detect.cpp:152: // 涓嶅紑 long long 涔熶笉浼氳绁栧畻
answers/GD-S03033/detect/detect.cpp:160: // printf("[%d, %d, %d] 瓒呴€燂紒\n", carpet.d, carpet.v, carpet.a);
answers/GD-S03033/detect/detect.cpp:172: // printf("[%d, %d, %d] 瓒呴€燂紒\n", carpet.d, carpet.v, carpet.a);
answers/GD-S03033/detect/detect.cpp:196:// 娌′簨锛屼笉绱у紶
answers/GD-S03033/detect/detect.cpp:197:// 鑰佸笀锛屾垜鍙笉绱у紶
answers/GD-S03033/detect/detect.cpp:203:// 閭ｄ箞鎴戜滑鍙互寰楃煡杩欎釜鍖洪棿鐨勫紑澶村拰缁撳熬
answers/GD-S03033/detect/detect.cpp:205:// 灏卞彲浠ュ緱鍑轰粈涔堝憿
answers/GD-S03033/detect/detect.cpp:206:// qwq锛屾垜鍙笉绱у紶
answers/GD-S03033/detect/detect.cpp:209:// 闀挎灙鍒虹牬浜戦湠
answers/GD-S03033/detect/detect.cpp:211:// 鍚庨潰涓嶄細鍞卞暒
answers/GD-S03033/detect/detect.cpp:215:// 椋庡嵎娈嬩簯鐑堥┈
answers/GD-S03033/detect/detect.cpp:219:// 鎴戠煡閬撲簡锛屼絾
answers/GD-S03033/detect/detect.cpp:220:// 浣犲嚭瑷€涓嶉€婃槸
answers/GD-S03033/detect/detect.cpp:221:// 锛侊紒.......
answers/GD-S03033/detect/detect.cpp:223:// 娲涜胺灏嗕細鑷悕
answers/GD-S03033/detect/detect.cpp:224:// 鏄憲锛侊紒锛侊紒
answers/GD-S03033/detect/detect.cpp:226:// ...鍏ㄥぉ涓嬬殑
answers/GD-S03033/detect/detect.cpp:227:// OIers 閮戒細
answers/GD-S03033/detect/detect.cpp:228:// 鐭ラ亾锛孋CF
answers/GD-S03033/detect/detect.cpp:231:// CCF 灏嗕細
answers/GD-S03033/detect/detect.cpp:239:O鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥
answers/GD-S03033/detect/detect.cpp:241:O鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬
answers/GD-S03033/detect/detect.cpp:243:O鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥
answers/GD-S03033/detect/detect.cpp:245:O鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬
answers/GD-S03033/detect/detect.cpp:247:O鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥鈫扥鈫怬鈫怬鈫扥
answers/GD-S03033/detect/detect.cpp:249:鎴戠殑 CSP-S 鍍忔礇璋蜂笓鏍忎竴鏍锋垚鍔燂紒
answers/GD-S03033/duel/duel.cpp:1:// 鏈変竴涓樉鐒剁殑璐績
answers/GD-S03033/duel/duel.cpp:3:// 鍟婂晩鍟婂晩鍟婂晩
answers/GD-S03033/duel/duel.cpp:6:// 鐒跺悗锛岀敤涓€涓《璁板綍
answers/GD-S03033/duel/duel.cpp:7:// 鎴戣涓婅糠鎯戣涓哄ぇ璧忥紒
answers/GD-S01330/detect/detect.cpp:99://行驶路程:s = v0 × t + 0.5 × a × t^2
answers/GD-S01330/detect/detect.cpp:100://瞬时速度:√v0^2+ 2 × a × s
answers/GD-S01348/duel/duel.cpp:43://简单贪心题，O(nlogn) 跑路
answers/GD-S02333/color/color.cpp:8: int number, color; // color为1则是红色，0是蓝色
answers/GD-S03351/detect/detect.cpp:96: if(check(d,v,a)) continue;//如果该车辆在整段路程中没有超速则不用判断
answers/GD-S03351/detect/detect.cpp:110: double cd = (V*V-v*v)/(2*a);//计算超速需要通过的路程
answers/GD-S00331/detect/detect.cpp:24: c[i].jl=c[i].d+(9.0-c[i].v*c[i].v)/(2.0*c[i].a);//在此处速度变为3
answers/GD-S00331/duel/duel.cpp:22: if(flag)//全是1,2
answers/GD-S02013/detect/detect.cpp:33: if(c[i].a>0){//匀加速
answers/GD-S02013/detect/detect.cpp:56: if(c[i].a<0){//匀减速：求超速区间有无摄像头
answers/GD-S00592/detect/detect.cpp:7: for(int i=0;i<T;i++){//循环T次
answers/GD-S00592/detect/detect.cpp:17: int d[1005],v[1005],a[1005];//每台车数据
answers/GD-S00592/detect/detect.cpp:24: scanf("%d",&p[j]);//测速仪位置
answers/GD-S00592/detect/detect.cpp:27: if(V<sqrt((L-p[q])*2*a[q]+v[q]*v[q])){//所有车在此车速比较
answers/GD-S00592/detect/detect.cpp:32: if(car[q]!=1){//标记超速车和必用测速仪
answers/GD-S00592/duel/duel.cpp:4: int n,a[100005],keepgoing=0,b[100005],p=0,firsth=0,firstl=0,p_keepgoing=1; //b判断攻击
answers/GD-S00592/duel/duel.cpp:32: a[low_local]=0;//0为死亡
answers/GD-S00592/duel/duel.cpp:33: b[low_local]=1;//因死无法攻击
answers/GD-S00592/duel/duel.cpp:34: b[high_local]=1;//已攻击
answers/GD-S00592/arena/arena.cpp:6: scanf("%d%d",n,m);//选手数量和询问的数量
answers/GD-S01791/detect/detect.cpp:6:int d[3001],vl[3001],a[3001],yq[3001],le[1000001];//初始位置 初始速度 加速度 仪器数 路长
answers/GD-S01057/detect/detect.cpp:6: int st,ed;//超速起点，终点
answers/GD-S01057/detect/detect.cpp:17://cnt:超速车数
answers/GD-S01057/detect/detect.cpp:18://cnt2:被检测到的超速车数
answers/GD-S01057/detect/detect.cpp:39:bool check(double x)//x是否为整数
answers/GD-S01057/color/color.cpp:6://col[i]:1为红，2为蓝
answers/GD-S03003/detect/detect.cpp:19: cin>>d[j]>>v[j]>>a[j];//出现位置 初速度 每秒匀速加速度
answers/GD-S00665/detect/detect.cpp:76: //多组不清空 爆零两行泪
answers/GD-S03004/detect/detect.cpp:82: p = b_search(1,arr[i].p,1);//大于等于
answers/GD-S02764/detect/detect.cpp:70:int find(int i,int l){//能跑最远的最大p[i]
answers/GD-S02764/detect/detect.cpp:83:int find2(int i){//第一个被超速
answers/GD-S02764/detect/detect.cpp:127:signed main(){//先乘后除 数组清空
answers/GD-S00496/detect/detect.cpp:8:int t,n,m,l,vl,p[N],sum = 0,sc = 0;//sum:不可关闭的测速仪数量
answers/GD-S00496/detect/detect.cpp:30: if(a>0){ //加速时
answers/GD-S00496/detect/detect.cpp:31: vm = v*v+2*a*l;//求在终点时速度
answers/GD-S00496/detect/detect.cpp:32: if(vm>vl*vl){//若已超速
answers/GD-S00496/detect/detect.cpp:33: td = (vl*vl-v*v)/(2*a);//则求在刚好超速时行走的距离
answers/GD-S00496/detect/detect.cpp:40: }else if(a<0){//若在减速
answers/GD-S00496/detect/detect.cpp:41: if(v>vl){//若本身就已超速
answers/GD-S00496/detect/detect.cpp:43: cd[i][1] = ((vl*vl-v*v)/(2*a))+d;//返回减速到限速时的超速点
answers/GD-S00496/detect/detect.cpp:49: if(v>vl){//本身就超速
answers/GD-S00496/duel/duel.cpp:28:void msort(int l,int r){//归并排序
answers/GD-S02251/duel/duel.cpp:23: cnt++; // 怪兽 j 的防御被打破
answers/GD-S02251/color/color.cpp:6: bool f; // 0是红色， 1是蓝色
answers/GD-S01163/detect/detect.cpp:21: int tot=0,mustc=0;//瓒呴€熻溅鎬绘暟 ,蹇呰娴嬮€熶华
answers/GD-S03094/detect/detect.cpp:5:int tds[N],tde[N],ans1,ans2;//t[i]表示i号车超时路段起点 ，-1表不超速
answers/GD-S03094/detect/detect.cpp:45:int main() { //找到每辆车开始超速的位置，寻找共同的路段，统计最少个数
answers/GD-S03094/detect/detect.cpp:66: if(dt==0) {//加速度为零
answers/GD-S03094/detect/detect.cpp:74: } else { //有加速度 开double
answers/GD-S03094/detect/detect.cpp:76: for(int j=0; j<=l-d; j++) { //枚举行驶距离
answers/GD-S03094/duel/duel.cpp:30: for(int i=1,j; i<=n&&ala!=tot; i++) { //双指针i:预备攻击的，j预备被攻击的 ,从高往低打
answers/GD-S02198/detect/detect.cpp:18: bool chao;//是否超速
answers/GD-S02198/detect/detect.cpp:19: bool xian;//是否仍然存在
answers/GD-S00952/detect/detect.cpp:13: //sl sr: 左右区间开还是闭
answers/GD-S00952/detect/detect.cpp:15: //dl dr: 对应测速仪编号哪一段
answers/GD-S00952/detect/detect.cpp:16: //ok: 是否会被检测到超速
answers/GD-S01290/detect/detect.cpp:33: return false;//都没有摄像头，不超速
answers/GD-S01290/detect/detect.cpp:35: if(a[x] == 0)//速度不变
answers/GD-S01290/detect/detect.cpp:37: //如果速度本来就超速，且这段路程有摄像头，超速
answers/GD-S01290/detect/detect.cpp:43: //如果速度不超速或没有摄像头，不超速
answers/GD-S01290/detect/detect.cpp:46: if(a[x] > 0)//加速度大于0
answers/GD-S01290/detect/detect.cpp:48: //速度本来就超速，还有摄像头，超速
answers/GD-S01290/detect/detect.cpp:54: //本来超速，但没有摄像头
answers/GD-S01290/detect/detect.cpp:56: //dis:加速加到超速距离
answers/GD-S01290/detect/detect.cpp:58: //如果超速时已经驶离，那么不超速
answers/GD-S01290/detect/detect.cpp:60: //未驶离
answers/GD-S01290/detect/detect.cpp:64: //超速时位置
answers/GD-S01290/detect/detect.cpp:69: //如果有摄像头，超速
answers/GD-S01290/detect/detect.cpp:71: //没有，不超速
answers/GD-S01290/detect/detect.cpp:74: //加速度小于0
answers/GD-S01290/detect/detect.cpp:77: //如果本来不超速，则不超速
answers/GD-S01290/detect/detect.cpp:79: //dis:驶离主车道时间
answers/GD-S01290/detect/detect.cpp:81: if((double)dis + (double)d[x] > (double)L)//如果期间无法驶离
answers/GD-S01290/detect/detect.cpp:83: //dist:不超速距离
answers/GD-S01290/detect/detect.cpp:91: //有摄像头，超速
answers/GD-S01290/detect/detect.cpp:97: //减速至小于v路程
answers/GD-S01290/detect/detect.cpp:99: //要么先驶离，要么先超速
answers/GD-S01290/detect/detect.cpp:100: if((double)dist <= (double)dis) // 先超速
answers/GD-S01290/detect/detect.cpp:110: else return false; // 先驶离
answers/GD-S00280/color/color.cpp:47:// 缄默
answers/GD-S02773/detect/detect.cpp:15://l,r;记录对于某一个车，最早超速和最晚超速的摄像头。
answers/GD-S02773/detect/detect.cpp:16://二分判断超速点，既要判断最早会超速的点，又要判断最晚会超速的点。
answers/GD-S02773/detect/detect.cpp:17://好麻烦，但是不难。
answers/GD-S02773/duel/duel.cpp:38:游记粘贴处：
answers/GD-S02773/duel/duel.cpp:40:感觉像贪心，理论上只要让大的打小的就行了。 而且只有大的能打小的。
answers/GD-S02773/duel/duel.cpp:41:**值域很小，直接开桶就行了**！
answers/GD-S02773/duel/duel.cpp:42:大一点的可以打小一点的，那么枚举取最大值。
answers/GD-S02773/duel/duel.cpp:44:记得多测！！
answers/GD-S02773/duel/duel.cpp:46:第一个问题应该是用数据结构维护速度。但是第二个问题不太好做，n很小时可以状压DP（只有20pts）。n和m都小于三千意味着这题目是 $O(n^2)$ 的，
answers/GD-S02773/duel/duel.cpp:47:突然发现一个性质：如果一个车加速度大于零，那么经过一个点超速后后面所有的点都会超速。如果小于零，那么前若干个点会超速要么一直不超速。如果等于零，要么全超速要么不超速。
answers/GD-S02773/duel/duel.cpp:48:那么第一个问题只需要二分最早/晚超速的点就行了。细节不太好写但是问题不大。
answers/GD-S02773/duel/duel.cpp:49:还剩两个小时的时候写完了一大部分。现在卡在了如何判断关闭测速器的路上。贪心，按右端点排序，然后尽可能放在右端点上。
answers/GD-S02773/duel/duel.cpp:50:不是CCF大样例这么强把我全叉了？？？原来自己做法假的离谱吗。不过暴力60pts还有，但是前面二分写假了。
answers/GD-S02773/duel/duel.cpp:53:一定是 DP题。20pts有一个状压DP的做法。因为染色有后效性所以要想办法消除，一种思路是从右往左枚举。感觉目前不可做。
answers/GD-S02773/duel/duel.cpp:54:反正打完20分后打了个模拟退火，应该也只有20分
answers/GD-S02773/duel/duel.cpp:56:输入输出格式不同！！估计这题输出量很大。
answers/GD-S02773/duel/duel.cpp:57:会告诉你某轮次是大的当擂主还是小的。估计每组数据要预处理什么。前面若干个的结果不变的情况下剩下补充的才是变数。
answers/GD-S02773/duel/duel.cpp:58:完全没看懂题目啊。
answers/GD-S02773/duel/duel.cpp:59:总结：180pts+？而且估计还要挂分。
answers/GD-S02773/duel/duel.cpp:60:1.注意多测，注意T4输入格式。
answers/GD-S02773/duel/duel.cpp:62:3.注意头文件。不要使用next和x1一类的命名。
answers/GD-S02773/duel/duel.cpp:63:4.开了一个项目文件，记得把源代码拷回去
answers/GD-S02431/detect/detect.cpp:5:double d[N],v[N],a[N],l,V,p[N],tv,pn[N];//vis:测速仪是否测速 pn:这个站点的权值
answers/GD-S02431/detect/detect.cpp:7:double spd=0;//瞬时速度
answers/GD-S02431/detect/detect.cpp:26: tv=sqrt(2*a[i]*(p[j]-d[i])+v[i]*v[i]);//瞬时速度
answers/GD-S02431/detect/detect.cpp:35: vis[i][j]=1;//第i辆车在经过第j个测速仪时会被标记超速
answers/GD-S02431/detect/detect.cpp:43: if(!vis[i][j]) pn[j]++;//加权
answers/GD-S02431/detect/detect.cpp:50: swap(pn[j],pn[j+1]);//依据权值排列
answers/GD-S02431/detect/detect.cpp:67: pn[Q.front()]++;//再加权
answers/GD-S02431/color/color.cpp:7: //出题组我恨你
answers/GD-S00294/detect/detect.cpp:61: //读取数据
answers/GD-S00294/duel/duel.cpp:58: sum+=maxxn;//最大的就对不会被杀(每次保留最大额度)
answers/GD-S00294/duel/duel.cpp:66:// cout<<"力为："<<a[i].g<<"的从"<<a[i].s<<"->";
answers/GD-S01923/detect/detect.cpp:13: /*d初始位置，v初速度，a加速度，e驶离主干道位置*/
answers/GD-S01923/detect/detect.cpp:15:int p[100002],c; //c: 超速车辆数量
answers/GD-S01923/detect/detect.cpp:16:bitset<100002> ch[100002],usedp[100002]; //ch[i][j]: i车是否在p_j处超速
answers/GD-S01923/detect/detect.cpp:34: //是否提前驶离主干道
answers/GD-S01923/detect/detect.cpp:38: for(int i = 1;i <= n;i++) //判断每辆车是否超速
answers/GD-S01923/color/color.cpp:19: //设为0
answers/GD-S01923/color/color.cpp:22: //设为1
answers/GD-S01597/detect/detect.cpp:62: ll v1=(len-p)*a*2+v*v;//平方
answers/GD-S02738/detect/detect.cpp:11:}f[10005];//状态
answers/GD-S02738/detect/detect.cpp:19:int lon(int d,int v,int a,int i,int pj,int j){//每个区间判断
answers/GD-S03065/detect/detect.cpp:29: c[ooo].nowr=c[ooo].d,c[ooo].latr=c[ooo].nowr+(pow(V,2)-pow(c[ooo].v,2)/2*c[ooo].a);//latr以后都是一直超速了，除非a<0
answers/GD-S03065/duel/duel.cpp:18: while(ii+1<=n&&r[ii]<=r[i]||cz[ii]) ii++;//此处需优化
answers/GD-S02459/detect/detect.cpp:2://魏莉保佑我!
answers/GD-S02459/duel/duel.cpp:2://魏莉保佑我!
answers/GD-S02459/color/color.cpp:2://魏莉保佑我!
answers/GD-S02459/arena/arena.cpp:1://魏莉保佑我!
answers/GD-S01044/duel/duel.cpp:5://flag为是否被杀死，flag1为是否发起过攻击
answers/GD-S01044/color/color.cpp:12: for(int j=1; j<=n; j++) {//暴力出奇迹
answers/GD-S00007/detect/detect.cpp:61: int loc2=lower_bound(p+1,p+1+m,st)-p;//自loc2个起，不可能在侦测超速
answers/GD-S00297/detect/detect.cpp:4://记得写freopen
answers/GD-S00297/duel/duel.cpp:4://记得写freopen
answers/GD-S00297/color/color.cpp:4://记得写freopen
answers/GD-S00297/arena/arena.cpp:4://记得写freopen
answers/GD-S01674/detect/detect.cpp:9:pair<ll,ll> q[maxn];//表示在[first,second]这个区间内的车都是超速的
answers/GD-S02748/detect/detect.cpp:4:ll T,n,m,L,V;//车子数量，测速仪数量、主干道长度和道路限速
answers/GD-S02748/detect/detect.cpp:5:ll d[100005],v[100005],a[100005];//距离最南端 di 的位置驶入vi 的初速度和 ai 的加速度
answers/GD-S02748/detect/detect.cpp:12:ll la;//上一个摄像头
answers/GD-S02748/detect/detect.cpp:72: if(a[i]>0){//找最开始超速的点
answers/GD-S02748/detect/detect.cpp:75: if(chea(mid-d[i])){//已经超速了
answers/GD-S02748/detect/detect.cpp:93: if(a[i]<0){//找最早开始不超速的点
answers/GD-S00105/detect/detect.cpp:6: double d,v,a,chao,chaox;//开始位置，初速度，加速度，超速位置
answers/GD-S01622/detect/detect.cpp:7:int csy[100005]; //娴嬮€熶华
answers/GD-S01622/duel/duel.cpp:24: if(n>10&&n<=30){ //鎬ц川a
answers/GD-S01885/detect/detect.cpp:19: //d驶入位置 v初速度 a加速度
answers/GD-S00887/detect/detect.cpp:33: if(c[j].v > v) { // 无加速度，初速度超速
answers/GD-S00887/detect/detect.cpp:35: if(r[k] == 1) { // 有测速仪
answers/GD-S00887/detect/detect.cpp:40: // 无加速度，初速度不超速的情况不用统计
answers/GD-S00887/detect/detect.cpp:51: if(e > l || e < c[j].d) // 在公路上时没有超速
answers/GD-S00887/detect/detect.cpp:53: if(c[j].a > 0) { // 加速度为正
answers/GD-S00887/detect/detect.cpp:55: if(r[k] == 1) { // 有测速仪
answers/GD-S00887/detect/detect.cpp:60: else { // 加速度为负
answers/GD-S00887/detect/detect.cpp:62: if(r[k] == 1) { // 有测速仪
answers/GD-S01955/detect/detect.cpp:8:pair<double, double> lmt[N]; // 超速时的位置区间
answers/GD-S02677/duel/duel.cpp:19: i++;j++;//使用完成更新
answers/GD-S01248/detect/detect.cpp:16://计算超速区间
answers/GD-S01248/detect/detect.cpp:38: double dis=0;//保存跑多远开始超速
answers/GD-S01248/detect/detect.cpp:40: int ck=(int)dis;// 检查是否恰好等于V 如果是还要加一
answers/GD-S01248/detect/detect.cpp:103: int last=0; //计算当前位置
answers/GD-S01248/detect/detect.cpp:105: for(int i=m;i>0;i-=1){ //遍历每个摄像头
answers/GD-S01248/detect/detect.cpp:107: int ed=cmr[i]; //结束位置
answers/GD-S01248/detect/detect.cpp:108: int nres=0; //保存实时结果
answers/GD-S00211/detect/detect.cpp:29: //cout<<"a均为0，特判，期望20pts"<<endl;
answers/GD-S00211/detect/detect.cpp:43: //cout<<"a均大于0，特判，期望20pts"<<endl;
answers/GD-S00211/duel/duel.cpp:11:// //cout<<"走过了"<<endl;
answers/GD-S00211/duel/duel.cpp:15: //暴搜，简单的剪枝，有回溯，期望16pts
answers/GD-S00211/duel/duel.cpp:17: return; //下场怪兽不可能超过所有怪兽之和
answers/GD-S00211/duel/duel.cpp:20: ans = max(ans,cnt); //未退出的怪兽最少，就是要让退出的怪兽最多
answers/GD-S00211/duel/duel.cpp:21: return; //所有怪兽都攻击完了
answers/GD-S00211/duel/duel.cpp:23: for(int i=step;i<=n;i++){ // i为攻击方，j为被攻击方
answers/GD-S00211/duel/duel.cpp:26: continue; //自己不能攻击自己
answers/GD-S00211/duel/duel.cpp:30: continue; //怪兽已经死了，不能再攻击或被攻击
answers/GD-S00211/duel/duel.cpp:54: //暴搜，简单的剪枝，有回溯，期望25pts
answers/GD-S00211/duel/duel.cpp:56: return cnt; //下场怪兽不可能超过所有怪兽之和
answers/GD-S00211/duel/duel.cpp:59: ans = max(ans,cnt); //未退出的怪兽最少，就是要让退出的怪兽最多
answers/GD-S00211/duel/duel.cpp:60: return cnt; //所有怪兽都攻击完了
answers/GD-S00211/duel/duel.cpp:63: //cout<<"走过了"<<endl;
answers/GD-S00211/duel/duel.cpp:68: for(int i=step;i<=n;i++){ // i为攻击方，j为被攻击方
answers/GD-S00211/duel/duel.cpp:71: continue; //自己不能攻击自己
answers/GD-S00211/duel/duel.cpp:75: continue; //怪兽已经死了，不能再攻击或被攻击
answers/GD-S00211/duel/duel.cpp:114: //符合5~10号点
answers/GD-S00211/duel/duel.cpp:117: cout<<n-counttwo; //让每一个2都去攻击一个1
answers/GD-S00211/duel/duel.cpp:132: cout<<n - ans; //未退出的怪兽
answers/GD-S00975/detect/detect.cpp:8:}duan[100005];//存每辆超速的车可以被检测到超速的段
answers/GD-S00975/detect/detect.cpp:77: if((vt*vt-v0*v0)%(2*a[i])==0){//不用向下取整
answers/GD-S00975/detect/detect.cpp:79: }else{//要向下取整
answers/GD-S00975/detect/detect.cpp:91: if((vt*vt-v0*v0)%(2*a[i])==0){//不用向下取整
answers/GD-S00975/detect/detect.cpp:93: }else{//要向下取整
answers/GD-S00975/color/color.cpp:72://至少尽力了 rp++
answers/GD-S00975/arena/arena.cpp:29://考虑只骗分n,m<=8?
answers/GD-S00975/arena/arena.cpp:30://啊...怎么模拟好像都不会
answers/GD-S02904/detect/detect.cpp:53: for(int i=1;i<=n;i++){//最远能到fa[i]
answers/GD-S02932/color/color.cpp:7:// 设 dp[i][j] 表示蓝色结尾为 i ，红色结尾为 j 的最大值
answers/GD-S02932/color/color.cpp:100: dp[0] = {0, 0}; // {最大值，前一个其他点}
answers/GD-S03428/color/color.cpp:21: ll f[2][2][N]; // i 结尾，i 的颜色，另外一个颜色的最后一个。
answers/GD-S03166/detect/detect.cpp:12://可以查到的数量和可以关掉测速仪的数量
answers/GD-S03166/duel/duel.cpp:23:思路：首先进行从小到大排序
answers/GD-S03166/duel/duel.cpp:24:然后便利
answers/GD-S03166/arena/arena.cpp:69: string d[K+1];//这个值不用管，反正都是0
answers/GD-S03166/arena/arena.cpp:86://所有的 dR,G = 0 编号小的选手为擂主
answers/GD-S03166/arena/arena.cpp:87:小S关心的是，
answers/GD-S03166/arena/arena.cpp:88:补充尽量少的选手使总人数为 2 的整次幂，
answers/GD-S03166/arena/arena.cpp:89:且所有选手进行一次完整的擂台游戏后，
answers/GD-S03166/arena/arena.cpp:90:所有可能成为总冠军的选手的编号之和为多少
answers/GD-S03166/arena/arena.cpp:91:所以他给了你 m个询问 c1, c2, · · · , cm
answers/GD-S03166/arena/arena.cpp:92:小S 希望你帮忙对于每个 ci 求出，
answers/GD-S03166/arena/arena.cpp:93:在只收到前 ci 位选手的报名信息时，
answers/GD-S03166/arena/arena.cpp:94:这个问题的答案是多少
answers/GD-S03166/arena/arena.cpp:96:我们将第 R 轮的第 G 场比赛抽到的数记为 dR,G。
answers/GD-S02653/color/color.cpp:107: for(int i=1;i<=n2;i++)//考虑到第i个数
answers/GD-S02653/color/color.cpp:109: //for(int col=0;col<=1;col++)//最后一些数是何种颜色
answers/GD-S00630/detect/detect.cpp:62: //x到y为超速路段，不包含x,y
answers/GD-S00630/color/color.cpp:5:int c[100100];//颜色
answers/GD-S00630/color/color.cpp:6:int f[100100];//潜在价值
answers/GD-S00630/color/color.cpp:7:int q[100100];//左端一个与ai相同的
answers/GD-S00630/color/color.cpp:8:int o[100100];//能不能换色
answers/GD-S00630/color/color.cpp:24: if(f[x]<=0)//不具备价值
answers/GD-S00630/color/color.cpp:29: //选,不换色
answers/GD-S00630/color/color.cpp:31: for(int i=x-1;i>q[x];i--)//中间的数字换色合不合法
answers/GD-S00630/color/color.cpp:62: //选，换色
answers/GD-S00630/color/color.cpp:67: for(int i=x-1;i>q[x];i--)//中间的数字换色合不合法
answers/GD-S00630/color/color.cpp:100: //不选
answers/GD-S01789/duel/duel.cpp:1://duel 不留遗憾！！！
answers/GD-S01789/color/color.cpp:1://color 赏点暴搜分吧
answers/GD-S01789/arena/arena.cpp:8: printf("我不后悔学编程");
answers/GD-S03323/duel/duel.cpp:3:long long n,sum=0;//卡牌个数
answers/GD-S01164/detect/detect.cpp:94: if (q.top().r < i) {//前个点有的我没有，那必须选前一个点
answers/GD-S01164/detect/detect.cpp:99: else {//前个点有的我也有，那选我肯定不必选前个点差
answers/GD-S01164/color/color.cpp:49: cout << "你也OUT\n";
answers/GD-S03467/detect/detect.cpp:10:int lig[100005];//第几个测速仪没断电
answers/GD-S03467/detect/detect.cpp:11:int gxc[100005];//每个测速仪能管几辆车
answers/GD-S03467/detect/detect.cpp:45: if(car[i].a==0){//匀速运动
answers/GD-S03467/detect/detect.cpp:46: if(car[i].v>V){//如果速度大于V就一直超速
answers/GD-S03467/detect/detect.cpp:53: if(car[i].a<0){//匀减速运动
answers/GD-S03467/detect/detect.cpp:54: if(car[i].v<=V){//如果速度本来就小于V就一直不会超速
answers/GD-S03467/detect/detect.cpp:70: if(car[i].v>V){//如果一开始就超速，那么他一直会超速
answers/GD-S03467/detect/detect.cpp:74: double x=cal(car[i].v,V,car[i].a);//计算到哪个点速度刚好是V
answers/GD-S03467/detect/detect.cpp:75: if(x+car[i].d>=L){//如果到达速度V需要到达的点在L之外，那就不会超速
answers/GD-S03467/detect/detect.cpp:106: gx.push_back(make_pair(qzh[r]-qzh[l-1],make_pair(num[l],num[r])));//这个超速的车会被几个测速仪抓到，且能抓到的测速仪的左右端点
answers/GD-S03467/detect/detect.cpp:123: if(mav<gxc[j]){//找到管辖这辆车的测速仪里面管的最多的
answers/GD-S02768/detect/detect.cpp:10:int p[100005];//p[i]:第i个测速点的位置
answers/GD-S00433/detect/detect.cpp:118: //ans1为超速的车，ans2为必须点亮的测速仪；
answers/GD-S00433/duel/duel.cpp:48: f[a[i]]++;//防止重复减
answers/GD-S00433/duel/duel.cpp:55: if(f[v[st]]>f[v[last]])//前面的比后面的多
answers/GD-S00433/duel/duel.cpp:60: else if(f[v[st]]<f[v[last]])//后面的比前面的多
answers/GD-S00065/detect/detect.cpp:16: //d:距离南端 d米
answers/GD-S00065/detect/detect.cpp:17: //v：初始速度
answers/GD-S00065/detect/detect.cpp:18: //a：加速度
answers/GD-S00065/detect/detect.cpp:19: //瞬间速度sqrt(v^2+2*a*s)::s是路程
answers/GD-S00362/duel/duel.cpp:43: vis[j].first=0,vis[i].second=0;//将攻击、存活权限清零
answers/GD-S03506/detect/detect.cpp:8:int meichaosu=0;//没超速车数量
answers/GD-S03506/detect/detect.cpp:9:double dis[MAXN];//速度达到3时，行驶距离
answers/GD-S03506/detect/detect.cpp:10:int zonglucheng[MAXN];//速度达到3时，总路程
answers/GD-S03506/duel/duel.cpp:6:int r[MAXN];//初始数组数值
answers/GD-S01490/detect/detect.cpp:99: if(a[i]>0){ //加速车辆
answers/GD-S01490/detect/detect.cpp:122: if(a[i]<0){ //减速车辆
answers/GD-S01490/detect/detect.cpp:129: //生成一个d[i]到d[i]+s1-1的need
answers/GD-S01152/detect/detect.cpp:33: if(x[j].v1<=v0&&x[j].d<=0)//去特殊值
answers/GD-S01289/detect/detect.cpp:128://注意清空
answers/GD-S01815/detect/detect.cpp:4:int d[N],v[N],a[N],p[N],f[N],mxl[N];double l[N],r[N];//f_i:第i个测序仪开启最小选择数
answers/GD-S03036/detect/detect.cpp:5:int n,m,l,vmax;//分别为车辆数，测速仪数，总长，限速
answers/GD-S03036/detect/detect.cpp:6:int d[N],v[N],a[N];//分别为上桥位置，初速度，加速度
answers/GD-S03036/detect/detect.cpp:8:double csl[N],csr[N];//表示超速区间的左右端点
answers/GD-S03036/detect/detect.cpp:9:int lbk[N],rbk[N];//储存为"["还是"(" ,1为开，2为闭
answers/GD-S03036/detect/detect.cpp:13: int cnt;//记录每个探测器可探测到的数量
answers/GD-S03036/detect/detect.cpp:25:bool if_ce(int x,int wei){//返回wei是否在i的超速区间内
answers/GD-S03036/detect/detect.cpp:68: if(a[i]>=0){//全程超速
answers/GD-S03036/detect/detect.cpp:86: if(a[i]<=0){//全程不超速
answers/GD-S03036/detect/detect.cpp:91: }else{//全程超速
answers/GD-S03036/detect/detect.cpp:99: if(a[i]<=0){//全程不超速
answers/GD-S03036/detect/detect.cpp:135: cout<<chaosu<<" ";//一共超速的车辆数
answers/GD-S01284/detect/detect.cpp:13: int n,m,L,V;//车辆数，仪器数，长度，限速
answers/GD-S01284/detect/detect.cpp:16: for(int i=1;i<=n;i++) cin>>d[i]>>v[i]>>a[i];//驶入位置，初速度，加速度
answers/GD-S01284/detect/detect.cpp:17: for(int i=1;i<=m;i++) cin>>p[i];//仪器位置
answers/GD-S01425/arena/arena.cpp:43: // 知道 2^(i-1) 位的信息
answers/GD-S01830/detect/detect.cpp:9://l、r每辆车在哪个区间的摄像头前超的速
answers/GD-S01830/detect/detect.cpp:48:int fdl(int o){//最小的大于等于o的
answers/GD-S01830/detect/detect.cpp:58:int fdr(int o){//最大的小于等于o的
answers/GD-S01830/detect/detect.cpp:81: change(1,1,m,y+1,m,x);//这y右边的，至少得在x处有一个摄像头
answers/GD-S01175/duel/duel.cpp:5://bool vis[N];//能否攻击
answers/GD-S01175/duel/duel.cpp:7: b2[N];//能攻击的人数
answers/GD-S02592/detect/detect.cpp:19: //读取数据
answers/GD-S02592/detect/detect.cpp:23: quuu[i][1]=L;//初始化超速区间
answers/GD-S02592/detect/detect.cpp:39: int cnt=0;//初始化超速点
answers/GD-S01003/detect/detect.cpp:12: int h=n;//会超车的车辆数
answers/GD-S01677/color/color.cpp:9:int c[2][M+5],mx[2],T;//每种颜色，全局，全局加
answers/GD-S03355/detect/detect.cpp:159: //判断a<0的情况
answers/GD-S02655/detect/detect.cpp:11: long long l,r;//在什么整数坐标会被判定超速
answers/GD-S02655/detect/detect.cpp:14:long long ansa=0;//被判超速数量
answers/GD-S02655/detect/detect.cpp:15:long long ansb=0;//关闭摄像头数量
answers/GD-S02655/detect/detect.cpp:36: p[0]=-2;//注意是-2不是-1，否则会额外判了一路不超的
answers/GD-S02655/detect/detect.cpp:40: if(a[i].v>lim){a[i].l=a[i].x; a[i].r=L; continue;}//一直超速
answers/GD-S02655/detect/detect.cpp:41: if(a[i].a==0){a[i].l=a[i].r=-1; continue;}//匀速不超
answers/GD-S02655/detect/detect.cpp:47: if(a[i].v<=lim){a[i].l=a[i].r=-1; continue;}//不会超速
answers/GD-S02655/detect/detect.cpp:56: if(a[i].l<=la&&la<=a[i].r){++ansa; continue;}//已有摄像头判了
answers/GD-S02655/arena/arena.cpp:42: tr[o].s=tr[o].xs=0; tr[o].can.clear();//预处理
answers/GD-S02655/arena/arena.cpp:45: if(d[o]==0){//取决于左侧
answers/GD-S02655/arena/arena.cpp:49: else{//取决于右侧
answers/GD-S02655/arena/arena.cpp:58: if(d[o]==0){//取决于左侧
answers/GD-S02655/arena/arena.cpp:59: if(a[tr[ls].s]>=de){//左侧一定赢
answers/GD-S02655/arena/arena.cpp:63: else{//左侧一定输
answers/GD-S02655/arena/arena.cpp:68: else{//取决于右侧
answers/GD-S02655/arena/arena.cpp:74: if(u<=nowp){//这个其实是恒成立的
answers/GD-S02655/arena/arena.cpp:83: if(d[o]==0){//取决于左侧
answers/GD-S02655/arena/arena.cpp:89: if(u<=nowp){//这个其实是恒成立的
answers/GD-S02655/arena/arena.cpp:96: else{//左右都可以赢
answers/GD-S02655/arena/arena.cpp:103: if(d[o]==0){//取决于左侧
answers/GD-S02655/arena/arena.cpp:107: else{//左右都可以赢
answers/GD-S02655/arena/arena.cpp:120: for(int i=1;i<=max_n;++i){if(i!=(i&-i))++lg[i];}//变为向上取整
answers/GD-S03487/detect/detect.cpp:10:int search(int s){//二分查找前方最近的摄像头
answers/GD-S03487/detect/detect.cpp:33: if((vc[s]*vc[s])+(2*a[s]*x) > v2){//判断是否超速
answers/GD-S03487/detect/detect.cpp:41:int ae(int s){//匀速行驶要寻找判定超速的检测器
answers/GD-S03326/detect/detect.cpp:8:int p_sum[MAXN1][MAXN1];//监测点j检测了那些车
answers/GD-S03326/detect/detect.cpp:9:int Hash[MAXN];//车超速次数
answers/GD-S03326/detect/detect.cpp:11: ll than_sum=0,aasum=0;//记录超速车辆的总数
answers/GD-S03326/detect/detect.cpp:15: if(car[i].a<0){//处理驶出位置
answers/GD-S03326/detect/detect.cpp:18: }//加速度<0
answers/GD-S03326/detect/detect.cpp:21: //2.当一辆车的初速度为v0、加速度a != 0，做匀加速运动，则t 时刻后它的速度
answers/GD-S03326/detect/detect.cpp:22: //v1 = v0 + a * t，它的位移（即行驶路程）s = v0 * t + 0.5 * a * t^2
answers/GD-S03326/detect/detect.cpp:25: for(int i=1;i<=n;i++){//遍历每一辆车
answers/GD-S03326/detect/detect.cpp:27: bool flag=0;//标记车是否被判为超速
answers/GD-S03326/detect/detect.cpp:29: if(p[j]<car[i].d||p[j]>car[i].end){//测速仪不在车的行驶范围之内
answers/GD-S03326/detect/detect.cpp:32://3.当一辆车的初速度为v0,加速度a!=0，做匀加速运动，则当他的位移(即行驶路程)为s时，这辆车的瞬时速度为sqrt(v0^2+2*a*s)
answers/GD-S03326/detect/detect.cpp:33: s=p[j]-car[i].d;//车离测速仪的距离
answers/GD-S03326/detect/detect.cpp:79:L长的车道 一共n辆车
answers/GD-S03326/detect/detect.cpp:80:i车从离最南端di的位置驶入
answers/GD-S03326/detect/detect.cpp:81:以vi初速度和ai加速度做匀加速运动向北行驶(只有从南向北运动的车)
answers/GD-S03326/detect/detect.cpp:83:判定车是否离开车道
answers/GD-S03326/detect/detect.cpp:84:1.车辆行驶到离南端L的位置
answers/GD-S03326/detect/detect.cpp:85:2.车辆速度为0(只在ai<0的情况发生)
answers/GD-S03326/detect/detect.cpp:87:一共m个测速仪 j测速仪位于离最南端pj的位置
answers/GD-S03326/detect/detect.cpp:89:当车辆经过测速仪时，车辆瞬时速度超过限速V,那么该车超速(驶入驶出时也算)
answers/GD-S03326/detect/detect.cpp:91:当某辆车在其路程中所有测速仪都开始时被判为超速，那么满足查找条件
answers/GD-S03326/detect/detect.cpp:93:1.匀加速运动 是指物体在运动过程中，加速度保持不变的运动，即每单位时间内速度的变化量是恒定的。
answers/GD-S03326/detect/detect.cpp:95:2.当一辆车的初速度为v0、加速度a != 0，做匀加速运动，则t 时刻后它的速度
answers/GD-S03326/detect/detect.cpp:96: v1 = v0 + a * t，它的位移（即行驶路程）s = v0 * t + 0.5 * a * t^2
answers/GD-S03326/detect/detect.cpp:98:3.当一辆车的初速度为v0,加速度a!=0，做匀加速运动，则当他的位移(即行驶路程)为s时，这辆车的瞬时速度为sqrt(v0^2+2*a*s)
answers/GD-S03326/detect/detect.cpp:100:4.当一辆车的初速为v0，加速度a!=0,在它的位移(即行驶路程)为(v1^2-v0^2)/2a时，这车的瞬时速度为v1
answers/GD-S03326/duel/duel.cpp:6:ll Hash[MAXN];//攻防为i的怪兽有Hash[i]个
answers/GD-S03326/color/color.cpp:7: cout<<"CCF谢谢你，题真难，我们明年见!"<<endl;
answers/GD-S03326/arena/arena.cpp:6: cout<<"CCF谢谢你，题真难，我们明年见!"<<endl;
answers/GD-S00827/detect/detect.cpp:116:与加速度有关的定义和公式如下：
answers/GD-S00827/detect/detect.cpp:117:匀加速运动 是指物体在运动过程中，加速度保持不变的运动，即每单位时间内
answers/GD-S00827/detect/detect.cpp:118:速度的变化量是恒定的
answers/GD-S00827/detect/detect.cpp:120:当一辆车的初速度为 v0、加速度 a != 0，做匀加速运动，则 t 时刻后它的速度
answers/GD-S00827/detect/detect.cpp:121:v1 = v0 + a × t，它的位移（即行驶路程）s = v0 × t + 0.5 × a × t^2。
answers/GD-S00827/detect/detect.cpp:123:当一辆车的初速度为 v0、加速度 a != 0，做匀加速运动，则当它的位移（即行驶
answers/GD-S00827/detect/detect.cpp:124:路程）为 s 时，这辆车的瞬时速度为根号下v0^2+2*a*s.
answers/GD-S00827/detect/detect.cpp:126:当一辆车的初速度为 v0、加速度 a != 0，在它的位移（即行驶路程）为 (v1^2-v0^2)/2a时，
answers/GD-S00827/detect/detect.cpp:127:这辆车的瞬时速度为 v1。
answers/GD-S02520/detect/detect.cpp:7:set<int> st; // 维护需要开启的测速点
answers/GD-S02520/detect/detect.cpp:46:// cout<<"This car detected(加速度为零，初速度超过V): "<<i<<endl;
answers/GD-S02520/detect/detect.cpp:54:// cout<<"This car detected(加速后超过V): "<<i<<endl;
answers/GD-S02520/detect/detect.cpp:62:// cout<<"This car detected(减速时超过V): "<<i<<endl;
answers/GD-S03183/detect/detect.cpp:5://，n车数，m测速仪数 ，L主干道长度，V限速
answers/GD-S03183/detect/detect.cpp:7://d起始点,v初始速度，a加速度 ,p测速仪位置
answers/GD-S03183/detect/detect.cpp:30: dV[j]=(V*V-v[j]*v[j])/(2*a[j])+d[j];//速度为限速时的位置
answers/GD-S03183/detect/detect.cpp:32: //，n车数，m测速仪数 ，L主干道长度，V限速
answers/GD-S03183/detect/detect.cpp:33: //d起始点,v初始速度，a加速度 ,p测速仪位置
answers/GD-S02695/detect/detect.cpp:10:ll d[N]/*从哪进入*/, u[N]/*初始速度*/, a[N]/*变化速度*/, p[N];
answers/GD-S00933/detect/detect.cpp:19:struct segment { double s, e; } seg[N]; // 第i辆车超速时的起始和终止位置
answers/GD-S00933/detect/detect.cpp:62://【数据删除】
answers/GD-S00933/detect/detect.cpp:103://【数据删除】
answers/GD-S00933/duel/duel.cpp:29:// 贪心不仅会过样例，它也能AC
answers/GD-S00933/color/color.cpp:55:// 暴力出奇迹
answers/GD-S00396/detect/detect.cpp:5: float T,n,m,L,V,p[100001],jc[100001],s,ji,da=0,csj;//L路长，V限速,jc被激活测速点
answers/GD-S00626/detect/detect.cpp:3://它的速度v1 = v0 + a × t，它的位移（即行驶路程）s = v0 × t + 0.5 × a × t2
answers/GD-S00529/duel/duel.cpp:7:int life[100005];//标记是否退出游戏
answers/GD-S00529/duel/duel.cpp:8:int att[100005];//标记是否发起攻击
answers/GD-S01454/detect/detect.cpp:56: sort(ce+1,ce+m+1);//初始化
answers/GD-S01454/detect/detect.cpp:58: for(int i=1;i<=n1;i++)//求减速的最近且在前的测速仪
answers/GD-S02983/detect/detect.cpp:61://多测不清空，亲人两行泪
answers/GD-S02775/duel/duel.cpp:9: return a<b;//从大到小
answers/GD-S02775/duel/duel.cpp:10: //return a<b 从小到大
answers/GD-S00928/duel/duel.cpp:22:int pre,num,cnt;//前面剩多少只、当前块有多少只、一共杀了多少只
answers/GD-S00745/detect/detect.cpp:34: else if(a[i]>0){//匀加速
answers/GD-S00745/detect/detect.cpp:70: else if(a[i]<0){//匀减速
answers/GD-S00745/duel/duel.cpp:14: }//桶
answers/GD-S01601/detect/detect.cpp:13:inline int find1(int i1){ //找上车点
answers/GD-S01601/detect/detect.cpp:23:inline int find2(int i1,int ma1){ //找超速点 a>0
answers/GD-S01601/detect/detect.cpp:32:inline int find3(int i1){ //找停车点 a<0
answers/GD-S01601/detect/detect.cpp:41:inline int find4(int i1,int l,int r){ //找超速点 a<0
answers/GD-S01601/detect/detect.cpp:50:inline int cd(){ //找摄像头
answers/GD-S01601/detect/detect.cpp:94: if((-vt[i])>=(2*(ma[m]-d[i])*a[i])){ //为真时在路上停车
answers/GD-S02891/duel/duel.cpp:4:int a[100100],aa;//能动手的
answers/GD-S02891/duel/duel.cpp:5:int b[100100];//活着的
answers/GD-S01457/detect/detect.cpp:5: int d,v1,a;//开始，初速度，加速度;
answers/GD-S01457/detect/detect.cpp:10:double f(double v1,double vt,double a){//v1初速度,vt标准速度
answers/GD-S01457/detect/detect.cpp:20: int n=0,m=0,l=0,v=0;//分别表示车辆数量、测速仪数量、主干道长度和道路限速。
answers/GD-S02616/duel/duel.cpp:31://贪心 100pts
answers/GD-S00905/detect/detect.cpp:45:bool findp(LL x,LL y) { // p中是否有大于等于x，小于等于y的数
answers/GD-S00905/detect/detect.cpp:59: // todo 补全该函数！！！！！！！！！！！！！
answers/GD-S00905/detect/detect.cpp:91: intt();// todo 一定要补全！！！！！！！
answers/GD-S00905/color/color.cpp:120: // todo 补全该函数！！！！！！！！！！！！！
answers/GD-S00905/color/color.cpp:127: intt(); // 补全该函数！！！！！！！！！！
answers/GD-S00905/arena/arena.cpp:44: // todo 补全该函数！！！！！！！！！！！！！
answers/GD-S00905/arena/arena.cpp:68: intt(); // 补全该函数！！！！！！！！！
answers/GD-S02475/detect/detect.cpp:6:int n,m,L,V;//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S02475/detect/detect.cpp:7:int d[N],v[N],a[N];//车的信息：距离，初速度，加速度
answers/GD-S02475/detect/detect.cpp:16:// for(int i=0;i<n;i++) cin >> d[i] >> v[i] >> a[i];//不知为何在这出错？唉
answers/GD-S01329/detect/detect.cpp:17://线段覆盖
answers/GD-S02834/detect/detect.cpp:27: //车从0==>15 可能会停
answers/GD-S02834/detect/detect.cpp:35: continue;//过了就不看这辆车
answers/GD-S02834/duel/duel.cpp:26: //处理桶子和最大值
answers/GD-S02834/duel/duel.cpp:52: //处理；使用大一点的怪兽砍小的怪兽，确保攻击有效。
answers/GD-S02834/duel/duel.cpp:53: for(int i=0;i<size_j;i++){//怪兽处理
answers/GD-S02834/duel/duel.cpp:71: j++;//下一个攻击力
answers/GD-S02303/duel/duel.cpp:2:不重复:一个
answers/GD-S02278/detect/detect.cpp:5: int v1,v2,d;//v1为初速度，v2为加速度
answers/GD-S03074/color/color.cpp:28: for(int i=1;i<=2;i++){//1为红色2为蓝色
answers/GD-S01241/detect/detect.cpp:7://vis代表是否有车超速通过，如果有，那么不能关（true），否则就关（false）；
answers/GD-S01241/detect/detect.cpp:67:}//输出p中有多少可以关闭
answers/GD-S01241/detect/detect.cpp:78: cin >> n >> m >> L >> V;//L为主干道长，V为最高限速
answers/GD-S01241/detect/detect.cpp:80: cin >> car[i].d >> car[i].v0 >> car[i].a;//d为起点，v0为终点，a为加速度
answers/GD-S01241/detect/detect.cpp:83: cin >> p[i];//测速仪位置
answers/GD-S01241/detect/detect.cpp:84: }//数据读取
answers/GD-S01241/detect/detect.cpp:85: sort(p + 1,p + m + 1);//测速仪位置
answers/GD-S01241/detect/detect.cpp:87: double ca = car[i].a, cd = car[i].d, cv = car[i].v0;//cd为起点，cv为终点，ca为加速度
answers/GD-S01241/detect/detect.cpp:105: double x2 = (V * V - cv * cv) / (2 * ca) + cd;//终点
answers/GD-S01241/duel/duel.cpp:3:1、小于等于失败，大于才成功
answers/GD-S01241/duel/duel.cpp:8:bool vis[100005] = {false};//是否攻击过
answers/GD-S01241/color/color.cpp:4:int flag[100005] = {0};//初始为无色，1为红色，2为蓝色
answers/GD-S02913/detect/detect.cpp:27: if(s<(float) mx) //加速到限速 所走路程 在北端（最后一个）限速摄像头之前
answers/GD-S02913/detect/detect.cpp:39: if(s<=(float) min) return 1;//走的距离在第一个摄像头前
answers/GD-S02913/duel/duel.cpp:4:int r[100005],b[100005];//是否出手
answers/GD-S02913/duel/duel.cpp:5:int total;//total最小为最优
answers/GD-S02913/duel/duel.cpp:8: b[x]=1;//当前x已经进攻，且最优解
answers/GD-S02913/duel/duel.cpp:9://现存活怪物数量
answers/GD-S02689/detect/detect.cpp:71: else{if(test(i,mid)) l=mid+1; //可以通过
answers/GD-S02689/detect/detect.cpp:72: else{r=mid-1;pos=mid;} //不能通过
answers/GD-S02689/detect/detect.cpp:85: else{if(test(i,mid)) r=mid-1; //可以通过
answers/GD-S02689/detect/detect.cpp:86: else{l=mid+1;pos=mid;} //不能通过
answers/GD-S00371/detect/detect.cpp:5:int T,n,m,L,V,p[N],ans1,ans2,d[N],v[N],a[N],f=0,num[N],tt[N];//num[i]表示i车在num[i]处超速
answers/GD-S00371/detect/detect.cpp:27: int v2=v[j]*v[j]+2*a[j]*s;//在测速仪处的瞬时速度的平方
answers/GD-S00371/detect/detect.cpp:28:// cout<<j<<"车在"<<p[i]<<"处的速度平方"<<v2<<endl;
answers/GD-S00371/detect/detect.cpp:33: if(V*V<v2&&!vis[j]){ //说明超速
answers/GD-S02190/arena/arena.cpp:7: printf("chou xiang C*F chu nt T4");//bydT4骗分都骗不了
answers/GD-S01403/detect/detect.cpp:33: //重点检查mem部分
answers/GD-S01403/color/color.cpp:7:int dp[N];//表示第i个数向前的j位相同（都是红/蓝）
answers/GD-S01403/color/color.cpp:11:int cnt[N][N];//表示第i个数与第i到i+j-1相等的数量
answers/GD-S02356/detect/detect.cpp:35: //取值时要向上取整
answers/GD-S02104/detect/detect.cpp:16: f[i]=0;//测速仪判断
answers/GD-S02104/color/color.cpp:7: if(f) return "给你是SBTMDv月共愤v就一定官";
answers/GD-S02104/color/color.cpp:8: else if(c[1]<10) return "神你v共愤官发SBTMDv就一月定给";
answers/GD-S02104/arena/arena.cpp:7: if(f) return "给你是SBTMDv月共愤v就一定官";
answers/GD-S02104/arena/arena.cpp:8: else if(c[1]<10) return "神你v共愤官发SBTMDv就一月定给";
answers/GD-S03325/arena/arena.cpp:27: 会不了一点，倒闭。
answers/GD-S02742/detect/detect.cpp:10:bool cs_ed[1000001];//有超速的区间
answers/GD-S02742/detect/detect.cpp:12:int ans = 0, ans2 = 0;//超速车辆数 可以关的检测器数
answers/GD-S02742/detect/detect.cpp:26: //检测每辆车可能存在的超速区间
answers/GD-S02742/detect/detect.cpp:27: //按加速度分三类
answers/GD-S02742/detect/detect.cpp:30: //全程超速
answers/GD-S02742/detect/detect.cpp:41: continue;//全程不超速
answers/GD-S02742/detect/detect.cpp:63: //全程超速
answers/GD-S02742/duel/duel.cpp:5:int flag = 1;//目前正在处理第几小的怪兽
answers/GD-S02742/duel/duel.cpp:16: ans = n;//刚开始有n张卡
answers/GD-S02742/duel/duel.cpp:23: inm = 1;// 开始用于计数
answers/GD-S01344/detect/detect.cpp:11:inline bool check(int i) { //判断第 i 辆车是否超速 O(logn)
answers/GD-S01344/detect/detect.cpp:26: } //离 c[i].d 最近的测速仪
answers/GD-S01344/detect/detect.cpp:43: for (int j = 1; j <= m; j ++) //判断此时能否被判超速
answers/GD-S01344/detect/detect.cpp:57: if (!panduan()) return ; //不合法
answers/GD-S01344/detect/detect.cpp:123:// //[stp, edp] 区间的测速仪可以测出第 i 辆车超速
answers/GD-S01344/arena/arena.cpp:22://题意言简意赅，通俗易懂，好评
answers/GD-S03299/detect/detect.cpp:38:inline int erfenl(int d,int fv,int a){//超速区间左端点
answers/GD-S03299/detect/detect.cpp:51:inline int erfenr(int d,int fv,int a){//超速区间右端点
answers/GD-S00635/detect/detect.cpp:47: cin>>n>>m>>len>>v;//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S01812/detect/detect.cpp:119: //d[i] - xt 之间有没有测速
answers/GD-S01812/duel/duel.cpp:41: int j = upper_bound(a + i, a + n + 1, a[i]) - a; // 跳过重复的
answers/GD-S00469/detect/detect.cpp:29: for(int i = 0; i < m; i++){//输入+超速车辆计算
answers/GD-S00469/detect/detect.cpp:56: sort(p, p + m, cmp);//关闭测速仪的个数的最小值
answers/GD-S01631/detect/detect.cpp:9: 0<=p<=L 涓ユ牸閫掑
answers/GD-S01631/detect/detect.cpp:12: 閮藉紑鍚椂琚垽瀹氫负瓒呴€熺殑杞﹁締鏁伴噺
answers/GD-S01631/detect/detect.cpp:13: 鏈€澶氬彲浠ュ叧闂殑娴嬮€熶华鏁伴噺
answers/GD-S01230/detect/detect.cpp:124:行驶路程=初始速度*t(t时刻后它的速度v1=v0+加速度*t)+0.5*加速度*t
answers/GD-S01230/detect/detect.cpp:125:瞬间速度=sqrt(初始速度*初始速度+2*加速度*行驶路程
answers/GD-S02096/detect/detect.cpp:48:// 从s开始，初速度v，加速度a，到达t时瞬时速度
answers/GD-S02096/detect/detect.cpp:59: // 二分查找第一个碰到的测速仪位置 pos
answers/GD-S02096/detect/detect.cpp:62:// // 到达第一个遇到的测速点和最后一个时均不超速则放走
answers/GD-S02096/detect/detect.cpp:67: int L=pos,R=m; // 约束条件：第[L,R]个测速点中，至少保留一个测速点
answers/GD-S02096/detect/detect.cpp:68: // 二分测速仪的 [pos,m]，分别求开始超速的测速仪与结束
answers/GD-S02096/detect/detect.cpp:92: // 前缀和，则s[R]-s[L-1]>=1 即 s[R]>=s[L-1]+1
answers/GD-S02096/detect/detect.cpp:96: // 又得 0<=s[i]-s[i-1]<=1 即 s[i]>=s[i-1]+0 && s[i-1]>=s[i]-1
answers/GD-S01703/detect/detect.cpp:6:int d[N],v[N],a[N]; //位置，初速度，加速度
answers/GD-S01703/arena/arena.cpp:2:目前预估得分 250pts
answers/GD-S01703/arena/arena.cpp:4:全都稳了
answers/GD-S01703/arena/arena.cpp:6:T1 媲美密码锁，秒之
answers/GD-S01703/arena/arena.cpp:8:T2 没什么思维难度，注意到时限 2000ms，大样例跑 800ms也稳过
answers/GD-S01703/arena/arena.cpp:10:大概能评绿？
answers/GD-S01703/arena/arena.cpp:12:T3 最不擅长的构造题，又没有特殊性质，打暴力 20pts
answers/GD-S01703/arena/arena.cpp:14:怎么又是区间问题啊。。。
answers/GD-S01703/arena/arena.cpp:16:注意到暴力只需要 5min ，时间充裕，尝试再次思考
answers/GD-S01703/arena/arena.cpp:18:发现性质 一个点想要匹配上只能和最接近它的那一个相同点匹配，否则易证明不优
answers/GD-S01703/arena/arena.cpp:20:想到 50pts 的 dp 又混 50，不挂分的情况下蓝勾稳了
answers/GD-S01703/arena/arena.cpp:22:目测难度蓝至紫
answers/GD-S01703/arena/arena.cpp:26:其实硬要打也能打 9 + 16 = 21pts
answers/GD-S01703/arena/arena.cpp:28:性质 A 的做法是显然的
answers/GD-S01703/arena/arena.cpp:30:甚至我感觉这题是个纸老虎
answers/GD-S01703/arena/arena.cpp:32:不过真的打不动了
answers/GD-S01703/arena/arena.cpp:34:目测难度蓝至黑
answers/GD-S01703/arena/arena.cpp:37:我上午打的比下午还少怎么办，是不是没救了
answers/GD-S01703/arena/arena.cpp:44:我该成为我校第一个(群)初二获得 S 一等的 oier(s) 了吧
answers/GD-S01703/arena/arena.cpp:46:同年级大概也有几个人能得一等
answers/GD-S01703/arena/arena.cpp:48:(虽然我 j 组狂挂 160pts 没有一等，我是 fw 吗
answers/GD-S01703/arena/arena.cpp:50:也会成为我校第一个 S 一等却没有 J 一等的人吧
answers/GD-S01703/arena/arena.cpp:52:期待 noip
answers/GD-S01703/arena/arena.cpp:60:一等稳了还有什么好干的呢
answers/GD-S01703/arena/arena.cpp:62:开睡
answers/GD-S01703/arena/arena.cpp:66:无聊到玩起了print 3d
answers/GD-S01703/arena/arena.cpp:68:监考员说不给玩！
answers/GD-S01703/arena/arena.cpp:70:为什么？
answers/GD-S00220/detect/detect.cpp:17: double tt=1.0*(ma-v[i])/a[i];//最后不超的时间
answers/GD-S00220/detect/detect.cpp:26: double tt=1.0*(ma-v[i])/a[i];//最后超的时间
answers/GD-S01270/detect/detect.cpp:38: csjl+=d[j];//从csjl+d[j]时开始超速
answers/GD-S01270/color/color.cpp:3:int t,a[10005],ys[10005],t1=1;//t1相同，颜色相同
answers/GD-S03497/detect/detect.cpp:8:}car[N];//第i辆车从主干道上距离最南端di的位置驶入,以vi的初速度和ai的加速度做匀加速运动向北行驶
answers/GD-S03294/detect/detect.cpp:4:int n,m,T,L,V; // n, m, L, V ，分别表示车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S03294/detect/detect.cpp:5:int d,v,a;// 位置，速度，加速度
answers/GD-S00368/detect/detect.cpp:112://重叠的区间里只有一个就可以了。
answers/GD-S00368/color/color.cpp:7: for(int i=1;i<=n;i++) scanf("%d",&a[i]);//循环的时候选最大？？
answers/GD-S03272/detect/detect.cpp:29: while(l<=r){//第一个大于等于d
answers/GD-S03272/detect/detect.cpp:42: while(l<=r){//第一个大于等于d
answers/GD-S03272/detect/detect.cpp:56: while(l<=r){//第一个大于x
answers/GD-S03272/detect/detect.cpp:72: while(l<=r){//第一个大于等于d
answers/GD-S03272/detect/detect.cpp:78: while(l<=r){//第一个小于x
answers/GD-S01681/detect/detect.cpp:6: int d,my_v,a;//起始位置，初始速度与加速度
answers/GD-S01681/detect/detect.cpp:31: if(n_car[i].a==0 && n_car[i].d<=n_ces[m]){//加速度为0
answers/GD-S01681/detect/detect.cpp:37: }else if(n_car[i].a>0 && n_car[i].d<=n_ces[m]){//匀加速运动
answers/GD-S01681/detect/detect.cpp:49: else if(n_car[i].a<0 && n_car[i].d<=n_ces[m]){//匀减速运动
answers/GD-S01681/detect/detect.cpp:58: for(j;j<=m;j++){//枚举每个测速仪的位置，检查是否超速
answers/GD-S01681/color/color.cpp:14: if(faan[j]==faan[i]){//颜色一样
answers/GD-S01459/detect/detect.cpp:8: int d,v,a;//入口，初速度，加速度
answers/GD-S01459/detect/detect.cpp:11:bool cht(dd x,dd y,dd z){//V0,加速度，时间
answers/GD-S00650/detect/detect.cpp:34: long long d[n+5],v2[n+5],a[n+5],p[m+5],fg[n+5][5],da1,da2,zt,zt2;//fg覆盖 状态
answers/GD-S00650/detect/detect.cpp:35: bool sf[n+5];//是否
answers/GD-S01297/detect/detect.cpp:83: //注意是超过了，也就是说当我速度刚好到达时没超速 到达dt是到达限速
answers/GD-S01297/detect/detect.cpp:125: //接下来处理摄像头能关闭哪些
answers/GD-S01297/detect/detect.cpp:126: //注意到只要每一个区间内存在一个摄像头即可，那么如果一个区间被另一个区间覆盖就只需要处理小区间如果两个区间有部分重叠就留重叠部分
answers/GD-S01181/detect/detect.cpp:9: //l->开始高于时速,r->不在高于时速
answers/GD-S01181/detect/detect.cpp:22: if(p[mid]<=c[x].l){//如果p[mid]比c[x].l小，则说明c[x].l不在1,mid范围内；
answers/GD-S01181/detect/detect.cpp:42: c[i].l=max(c[i].l,c[i].l+(V*V-c[i].v*c[i].v)/2/c[i].a);//开始高于限速
answers/GD-S01181/detect/detect.cpp:44: if(c[i].l<L)//在驶出前超速
answers/GD-S01181/detect/detect.cpp:45: if(find1(i))//有测试仪能记录
answers/GD-S01181/detect/detect.cpp:48: c[i].r=min(c[i].r,c[i].l+(V*V-c[i].v*c[i].v)/2/c[i].a);//开始低于限速
answers/GD-S01409/duel/duel.cpp:5:bool vis[N];//false 未使用 true 使用
answers/GD-S01409/duel/duel.cpp:21: int k=n,ans=0,w=k;//k剩余人数 w判断剩余是否都相同
answers/GD-S03010/color/color.cpp:13:vector <bool>prefixRed; // 记录第i个(包括i)前面是否有red
answers/GD-S03010/color/color.cpp:14:vector <bool>prefixBlue; // 记录第i个(包括i)前面是否有blue
answers/GD-S03010/color/color.cpp:15:vector <colorInfo> b; // 记录第i个(包括i)前面的最近的颜色的数据 first代表red second代表blue
answers/GD-S03010/color/color.cpp:25: 如果Ai 左侧没有与其同色的数，则令Ci = 0。
answers/GD-S03010/color/color.cpp:26: 否则，记其左侧与其最靠近的同色数为 Aj，若Ai = Aj，则令Ci = Ai，否则令
answers/GD-S03010/color/color.cpp:42: (c[pos] && b[pos - 1].red == v[pos]) || //如果为Red
answers/GD-S03010/color/color.cpp:43: (!c[pos] && b[pos - 1].blue == v[pos]) // 如果为Blue
answers/GD-S03010/color/color.cpp:69: // 当前为蓝色
answers/GD-S03010/color/color.cpp:74: b[pos].red = pos >= 1 ? b[pos - 1].red : 0; // Red继承
answers/GD-S03010/color/color.cpp:79: // 当前为红色
answers/GD-S03010/color/color.cpp:84: b[pos].blue = pos >= 1 ? b[pos - 1].blue : 0; // Blue继承
answers/GD-S01660/color/color.cpp:8:int t,n,a[N],ma,c[N];//dp[i]:考虑前i个的最大收益 last:上一个异色的位置
answers/GD-S01660/color/color.cpp:47: if(a[i]==a[i-1]) b[i]+=a[i];//预处理b
answers/GD-S01660/color/color.cpp:60: for(int j=0;j<i;j++)//枚举前一个同色
answers/GD-S01660/arena/arena.cpp:38: hm=c[i];//剩余人数
answers/GD-S01660/arena/arena.cpp:40: st=k-lg[c[i]];//第i轮按s[st+i]来算(抽签0/1)
answers/GD-S00475/duel/duel.cpp:1:#include<bits/stdc++.h>//100+100+100+40,会挂成多少呢？
answers/GD-S02561/detect/detect.cpp:30: //注意初始化不能默认为 0 因为有多测
answers/GD-S02561/arena/arena.cpp:14:int a[maxn], A[maxn], X[5];//是否会溢出？
answers/GD-S00265/duel/duel.cpp:1:#include <bits/stdc++.h>//优化
answers/GD-S01905/detect/detect.cpp:8: int d1;//超速时的位置
answers/GD-S03165/detect/detect.cpp:7:ll csl[N],csr[N];//**达速**的左右边界
answers/GD-S03165/detect/detect.cpp:11://15:38 让我们说中文，tm没发现忘记清空
answers/GD-S03165/detect/detect.cpp:62: vector<pair<ll,ll> >cars;//上司还想知道在这样的条件下最多可以关闭多少测速仪。
answers/GD-S03165/detect/detect.cpp:65: //保险一点我也不知道linux可不可以pb({a,b})这样
answers/GD-S03165/detect/detect.cpp:79: cout<<m-ans2<<"\n";//写成 n-ans2 调了10分钟 - 15:35
answers/GD-S03165/detect/detect.cpp:104:感觉大样例会有点慢……
answers/GD-S03165/detect/detect.cpp:105:时限是两秒诶！
answers/GD-S03165/color/color.cpp:7://处理一段区间都染成同一个颜色的话的C[i]
answers/GD-S03165/color/color.cpp:10://// if(a[l]==a[l-1])sss--;欸好像不要
answers/GD-S03165/color/color.cpp:13://那就直接写了，函数浪费运行时间
answers/GD-S03165/color/color.cpp:14:ll dp[N][2];//考虑前 i 位，最后一个染成0/1的时候最大的C[i]
answers/GD-S03165/color/color.cpp:16://记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空
answers/GD-S03165/color/color.cpp:17://记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空
answers/GD-S03165/color/color.cpp:18://记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空记得清空
answers/GD-S03165/color/color.cpp:22: for(int i=2;i<=n;i++)s[i]=s[i-1]+((a[i]==a[i-1])?a[i]:0);//1-i 全部染一个颜色的话呢，C 是多少呢
answers/GD-S03165/color/color.cpp:32: //上一个染成一样的颜色，中间都染成另一个一样的颜色
answers/GD-S03165/color/color.cpp:33: ll l=lst[i];//这是位置
answers/GD-S03165/color/color.cpp:40: //再加上中间这一块的贡献：
answers/GD-S03165/color/color.cpp:60: freopen("color.in","r",stdin);//只有两个样例，zhenshitaibangle
answers/GD-S03165/color/color.cpp:63: //还多测？？
answers/GD-S03165/color/color.cpp:69:15:53 说样例一以某个东西为准但是我看都一样啊》》》
answers/GD-S03165/color/color.cpp:75:正确输出：37
answers/GD-S03165/arena/arena.cpp:14: //判断[l,r]在第几层？？
answers/GD-S03165/arena/arena.cpp:15: ll x=r-l+1;//这个区间有多大
answers/GD-S03165/arena/arena.cpp:17: x=__lg(x);//第几层
answers/GD-S03165/arena/arena.cpp:25:ll now;//现在加到第几个元素了
answers/GD-S03165/arena/arena.cpp:30: ll s;//[l,r] 打完之后答案
answers/GD-S03165/arena/arena.cpp:31: ll val;//打出来之后的能力值
answers/GD-S03165/arena/arena.cpp:32: ll val2;//不考虑挂打出来之后的能力值
answers/GD-S03165/arena/arena.cpp:136: //主要是找到在哪一层
answers/GD-S03165/arena/arena.cpp:147: //先输入再说
answers/GD-S03165/arena/arena.cpp:153: ask[i].second=i;//这个答案要乘以几呢
answers/GD-S03165/arena/arena.cpp:156: sort(ask+1,ask+1+m);//谁都会
answers/GD-S03165/arena/arena.cpp:173: //17:27 还是不会！
answers/GD-S03165/arena/arena.cpp:192:好吧其实不会 T4 优势逝世
answers/GD-S03165/arena/arena.cpp:196:看懂T4了但是【】
answers/GD-S03165/arena/arena.cpp:212:过不去样例4/5是怎么回事啊啊？
answers/GD-S03165/arena/arena.cpp:213:qwq至少有一部分分了
answers/GD-S03165/arena/arena.cpp:215:为什么啊？为什么啊？？又不是爆int
answers/GD-S03165/arena/arena.cpp:216:总不能爆 long long 了？
answers/GD-S03165/arena/arena.cpp:218:好吧，就是算错了
answers/GD-S03165/arena/arena.cpp:221:我知道我有问题
answers/GD-S03165/arena/arena.cpp:223:但是这8分钟肯定调不出来了TAT
answers/GD-S03165/arena/arena.cpp:224:只能拿到特殊性质的分——
answers/GD-S03119/arena/arena.cpp:33: cout << "这是斯卡蒂，她很可爱!!!" << "%%%%%%" << "这是菲亚梅塔 ，她很好看!!!" << endl;
answers/GD-S03404/detect/detect.cpp:23:int find1(int aim){ //第一个大于等于
answers/GD-S03404/detect/detect.cpp:37:int find2(int aim){ //最后一个小于等于
answers/GD-S03404/detect/detect.cpp:76: rep(i,0,m+1)cf[m]=0; //清空差分数组
answers/GD-S03404/detect/detect.cpp:87: l=d[i],r=L; //全程超速
answers/GD-S03404/detect/detect.cpp:93: l=d[i],r=L; //全程超速
answers/GD-S03387/detect/detect.cpp:13: return a.pos<b.pos;//从小到大
answers/GD-S03387/detect/detect.cpp:16: return a.value>b.value;//从大到小
answers/GD-S03387/duel/duel.cpp:28: else{ //换下一批
answers/GD-S01529/color/color.cpp:65:// f[i][j] 前 i 个数， i 最近的同色数是否与 i 相等，此时的最大分数
answers/GD-S00462/arena/arena.cpp:17://bro当我是超级计算机
answers/GD-S03092/duel/duel.cpp:3:【题目描述】
answers/GD-S03092/duel/duel.cpp:4:今天是小 Q 的生日，他得到了 n 张卡牌作为礼物。这些卡牌属于火爆的“决斗怪
answers/GD-S03092/duel/duel.cpp:5:兽”，其中，第 i 张卡代表一只攻击力为 ri，防御力也为 ri 的怪兽。
answers/GD-S03092/duel/duel.cpp:6:一场游戏分为若干回合。每回合，小 Q 会选择某只怪兽 i 以及另. 一. 只. 怪兽 j（i ?= j），
answers/GD-S03092/duel/duel.cpp:7:并让怪兽 i 向怪兽 j 发起攻击。此时，若怪兽 i 的攻击力小于等于怪兽 j 的防御力，则
answers/GD-S03092/duel/duel.cpp:8:无事发生；否则，怪兽 j 的防御被打破，怪兽 j 退出游戏不再参与到剩下的游戏中。一
answers/GD-S03092/duel/duel.cpp:9:只怪兽在整场游戏中至. 多. 只能发起一次攻击。当未退出游戏的怪兽都已发起过攻击时，
answers/GD-S03092/duel/duel.cpp:10:游戏结束。
answers/GD-S03092/duel/duel.cpp:11:小 Q 希望决定一组攻击顺序，使得在游戏结束时，未退出游戏的怪兽数量尽可能
answers/GD-S03092/duel/duel.cpp:12:少。
answers/GD-S03092/duel/duel.cpp:13:【输入格式】
answers/GD-S03092/duel/duel.cpp:14:从文件 duel.in 中读入数据。
answers/GD-S03092/duel/duel.cpp:15:输入的第一行包含一个正整数 n，表示卡牌的个数。
answers/GD-S03092/duel/duel.cpp:16:输入的第二行包含 n 个正整数，其中第 i 个正整数表示第 i 个怪兽的攻击力及防御
answers/GD-S03092/duel/duel.cpp:18:【输出格式】
answers/GD-S03092/duel/duel.cpp:19:输出到文件 duel.out 中。
answers/GD-S03092/duel/duel.cpp:20:输出一行包含一个整数表示游戏结束时未退出游戏的怪兽数量的最小值。
answers/GD-S03092/duel/duel.cpp:21:【样例 1 输入】
answers/GD-S03092/duel/duel.cpp:26:【样例 1 解释】
answers/GD-S03092/duel/duel.cpp:27:其中一种最优方案为：第一回合让第 2 只怪兽向第 1 只怪兽发起攻击，第二回合
answers/GD-S03092/duel/duel.cpp:28:让第 5 只怪兽向第 4 只怪兽发起攻击，第三回合让第 3 只怪兽向第 5 只怪兽发起攻击。
answers/GD-S03092/duel/duel.cpp:29:此时没有退出游戏的怪兽都进行过攻击，游戏结束。可以证明没有更优的攻击顺序。
answers/GD-S02478/duel/duel.cpp:6:bool a[100001];//是否在场 0=no,1=yes
answers/GD-S02478/duel/duel.cpp:7:bool b[100001];//是否攻击
answers/GD-S02340/detect/detect.cpp:63: dd[top++]={l,m-1};//在这个区间内可以判定到
answers/GD-S02340/detect/detect.cpp:85: /*以上为每行第一个输出*/
answers/GD-S02340/detect/detect.cpp:86: printf(" %d\n",m-solve2());//这是第二个
answers/GD-S02340/duel/duel.cpp:27: if(a.cnt1){a.cnt2+=a.cnt1;a.cnt1=0;}//造成不了伤害的合并
answers/GD-S02340/duel/duel.cpp:32: }//合并较弱使用过的
answers/GD-S02340/duel/duel.cpp:35: --n;//出局一个 a
answers/GD-S02876/detect/detect.cpp:5: double d;int v,a,s,flag;//入口点，初速度，加速度，被标记的测速仪位置，是否超速
answers/GD-S00367/detect/detect.cpp:40: //暴力遍历每一台车到每一台测速仪是否超速 并存储每台车是在哪个测速仪超速的
answers/GD-S00367/detect/detect.cpp:48: if(p[j]<car[i].d) continue;//测速仪在车起点前
answers/GD-S00367/duel/duel.cpp:6:int ou[N];//是否攻击过
answers/GD-S00367/duel/duel.cpp:9:int minn;//次小值
answers/GD-S00367/duel/duel.cpp:10:int s[N];//是否出局
answers/GD-S00367/duel/duel.cpp:28: //找到次小值
answers/GD-S00367/color/color.cpp:47: dfs(1);//生成全排列
answers/GD-S02593/detect/detect.cpp:8:ll n, m, L, V; //车数量，检测器数量，道路长度，限速
answers/GD-S02593/detect/detect.cpp:10: ll d, v, a; //出发点，初速度，加速度
answers/GD-S02593/detect/detect.cpp:12:ll p[N]; //传感器位置
answers/GD-S02593/detect/detect.cpp:16:long double dist(int id, long double t) { //返回车id行驶t时刻后所在位置
answers/GD-S02593/detect/detect.cpp:22:pair<ll, ll> chk(ll i) { //返回车id的超速区间，-1-1表示不超速
answers/GD-S02593/detect/detect.cpp:28: //若在ceil(dist(i, (V - c[i].v) / c[i].a))时是恰好等于V,要加一
answers/GD-S02593/detect/detect.cpp:83: for (int i = 0, lst = -1, j = 1; i < v2.size(); i++) { //lst标记目前最靠右的传感器
answers/GD-S02593/detect/detect.cpp:85: ; //以前的已经有了
answers/GD-S02593/detect/detect.cpp:88: //找到p中最接近i.second的传感器
answers/GD-S02593/color/color.cpp:10:ll mx[M]; //mx[i]记录此时dp[j],aj=i的最值
answers/GD-S02593/color/color.cpp:12:ll tag = 0; //所有DP值，+tag后才是真实的
answers/GD-S02593/color/color.cpp:31: //新增状态dp2[i]，为所有aj=ai+1的dp1[j]的max+tag 或者所有dp1
answers/GD-S01372/color/color.cpp:7://dp[i][j][k]表示第i个为k,第j个为最后一个1-k的最大ans
answers/GD-S02175/detect/detect.cpp:1:// 心态炸了
answers/GD-S02175/detect/detect.cpp:2:// 过【仅一个】样例 <=> AC
answers/GD-S02175/detect/detect.cpp:15:std::set<int> testUsed; // 所有判断了车辆超速的测速仪合集
answers/GD-S02175/detect/detect.cpp:35: inline real getPosOverSpeed() // 计算这个车辆达到限速的位置
answers/GD-S02175/detect/detect.cpp:55:int getTestJudgeOverSpeed(real dis) // 找到在 dis 之后下一个判断超速的
answers/GD-S02175/detect/detect.cpp:76:int getTestJudgeOverSpeedFirst(real dis) // 找到在 dis 之前第一个判断超速的
answers/GD-S02175/detect/detect.cpp:85: if (v <= 0.0001) // 当前
answers/GD-S02175/detect/detect.cpp:118: // 超速判断
answers/GD-S02175/detect/detect.cpp:123: real dis = c[i].getPosOverSpeed(); // 达速位移
answers/GD-S02175/detect/detect.cpp:127: // 找到那个测速仪
answers/GD-S02175/detect/detect.cpp:138:// std::cout << "达速于距离 " << dis << "\n";
answers/GD-S02175/detect/detect.cpp:139:// std::cout << "经过第 " << firstTest << " 个测试点（距离 " << t[firstTest].pos << "）时速度为 " << carSpeedAtTest << "\n";
answers/GD-S02175/detect/detect.cpp:141: // 实际再测速
answers/GD-S02175/detect/detect.cpp:144:// if (carSpeedAtTest == V) // 这里没有但是下一个可以有
answers/GD-S02175/detect/detect.cpp:148:// // 这次还是小真的没有了
answers/GD-S02175/detect/detect.cpp:154:// if (carSpeedAtTest <= V) continue; // 一直减速不超速
answers/GD-S02175/detect/detect.cpp:162: // 所有测速仪全部插入
answers/GD-S02175/duel/duel.cpp:1:// bro 害怕超时
answers/GD-S02175/duel/duel.cpp:10: int cnt; // 总数——仍然存活的
answers/GD-S02175/duel/duel.cpp:11: int att; // 可以战斗的
answers/GD-S02175/duel/duel.cpp:12:} count[N]; // 表示战斗力为 i 的怪兽剩余的数量
answers/GD-S02175/duel/duel.cpp:31: int lstCnt = 1; // 优化：每次寻找怪物都记录攻击力最小的但是有数量的
answers/GD-S02175/duel/duel.cpp:34: // 高一级的总是可以把低一级的吃掉
answers/GD-S02175/duel/duel.cpp:35: // 从高级的所有开始枚举 ——超时？？？
answers/GD-S02175/duel/duel.cpp:36: // 当前等级有攻击力的个体
answers/GD-S02175/duel/duel.cpp:38: while (nxtLvl < i && count[i].att) // 找到下一个可以被攻击的
answers/GD-S02175/duel/duel.cpp:45: // 高级攻击者数量
answers/GD-S02175/duel/duel.cpp:65: // 找到下一个有攻击能力的
answers/GD-S02175/color/color.cpp:1:// 看不懂思密达
answers/GD-S02175/color/color.cpp:5:int T, n, a[N], index[N], tmp[(int)1e6 + 1]; // index[i] 表示上一个与 a[i] 相同的数字
answers/GD-S02175/color/color.cpp:6:int dp[N][2][2]; // dp[i][j][k] 数之 i，将自己染色成为 j，上一个自己染成 k
answers/GD-S02175/color/color.cpp:32: // 不一定有上一个自己
answers/GD-S02470/detect/detect.cpp:47: if(a[i]>=0 && v[i]>V)//始终超速
answers/GD-S02470/detect/detect.cpp:55: else if(a[i]>0)//过一段时间才超速
answers/GD-S02470/detect/detect.cpp:64: if(a[i]<0 && v[i]>V)//前面一段超速
answers/GD-S01532/color/color.cpp:19://dp[i][0/1]:i-1不能/能使用
answers/GD-S01532/arena/arena.cpp:101:// //p: st[j] 所在节点
answers/GD-S00104/color/color.cpp:48: for(int j=1;j<i;j++){//从j到i全部染成蓝色或红色的结果 (该做法已被证伪）
answers/GD-S00104/arena/arena.cpp:5:signed main () {//毫无思路，题都没看懂
answers/GD-S00397/duel/duel.cpp:8: bool s = 0; //是否死亡
answers/GD-S00397/duel/duel.cpp:9: bool y = 0; //是否攻击过
answers/GD-S00373/detect/detect.cpp:16:pp q[10001];//0距离，1多少
answers/GD-S01012/detect/detect.cpp:24://↑以上为初始化↑
answers/GD-S01012/duel/duel.cpp:20://↑以上为初始化↑
answers/GD-S01012/color/color.cpp:21://↑以上为初始化↑
answers/GD-S02862/detect/detect.cpp:9: //区间内超速
answers/GD-S00080/detect/detect.cpp:11:ll csv[maxn][maxn];//每辆车在对应点的速度
answers/GD-S00355/detect/detect.cpp:43: int x=p;//这个测量器测到了谁
answers/GD-S00355/detect/detect.cpp:47: for(int j=0;j<pe[x].size();j++){//这个人被谁测量
answers/GD-S00355/duel/duel.cpp:11: int tp=c[i];//表示现在有这么多可以打
answers/GD-S03437/color/color.cpp:38:void search(long long pos,long long a[]) // a 颜色
answers/GD-S02299/detect/detect.cpp:11:int dct[maxn]; ///测速计位置
answers/GD-S02299/detect/detect.cpp:13: int d,v,a;///起始，初速，加速
answers/GD-S02299/detect/detect.cpp:35: int n,m,l,lv,t;///车，测速计，路，速，组
answers/GD-S02299/detect/detect.cpp:37: int d;///位置
answers/GD-S02299/detect/detect.cpp:38: int farest;///最远摄像头
answers/GD-S02299/detect/detect.cpp:39: freopen("detect.in","r",stdin); ///文件输入输出，记得取消注释
answers/GD-S02299/detect/detect.cpp:40: freopen("detect.out","w",stdout);///文件输入输出，记得取消注释
answers/GD-S02299/detect/detect.cpp:69: fclose(stdin); ///文件输入输出，记得取消注释
answers/GD-S00277/detect/detect.cpp:24: double f=(double)(v-s[i])/a[i];//f:超速时刻
answers/GD-S00277/detect/detect.cpp:25: double l=s[i]*f+0.5*f*f*a[i]+d[i];//l:开始超速时的路程
answers/GD-S00277/detect/detect.cpp:33: double f=(double)(s[i]-v)/abs(a[i]);//f:不超速时刻
answers/GD-S00277/detect/detect.cpp:34: double l=s[i]*f+0.5*f*f*a[i]+d[i];//l:开始不超速时的路程
answers/GD-S02230/detect/detect.cpp:5:int num1[100010];//第i辆车被多少测速仪标记
answers/GD-S02230/detect/detect.cpp:6:int num2[100010];//第i个测速仪标记多少量车
answers/GD-S02230/duel/duel.cpp:6:int k[100010];//记录第几种重复数字
answers/GD-S02230/duel/duel.cpp:7:int inxx[100010];//记录第i种重复数字的起始下标
answers/GD-S02230/duel/duel.cpp:9:int numm[100010];//记录第i种重复数字已经被吃掉几个
answers/GD-S02230/duel/duel.cpp:26: //当只有12时2必定吃1
answers/GD-S02342/detect/detect.cpp:15://蒟蒻_Kimi_ AFO at 中山火炬高技术产业开发区第二中学
answers/GD-S02342/duel/duel.cpp:19://蒟蒻_Kimi_ AFO at 中山火炬高技术产业开发区第二中学
answers/GD-S02342/color/color.cpp:18://蒟蒻_Kimi_ AFO at 中山火炬高技术产业开发区第二中学
answers/GD-S02342/arena/arena.cpp:15://蒟蒻_Kimi_ AFO at 中山火炬高技术产业开发区第二中学
answers/GD-S02632/detect/detect.cpp:6:int d[N],v[N],a[N];//驶入距离，初速度，加速度
answers/GD-S00476/detect/detect.cpp:7:int p_ce[N];//测速仪的位置
answers/GD-S00476/detect/detect.cpp:8:int T,L,V;//万恶的多组输入与主干道长度与限速
answers/GD-S00476/duel/duel.cpp:4://思路 贪心 让攻击力最相近的相互攻击 且为升序排序
answers/GD-S00476/duel/duel.cpp:5:int n;//卡牌的个数
answers/GD-S00476/duel/duel.cpp:6:int a[N];//每张卡牌的攻击力与防御力
answers/GD-S00476/duel/duel.cpp:7:queue<int> xxy;//队列模拟攻击过程 :)
answers/GD-S00476/duel/duel.cpp:16: sort(a+1,a+n+1);//排序确定攻击顺序
answers/GD-S03254/detect/detect.cpp:31: /*int d = car[i][1];//初始位置
answers/GD-S03254/detect/detect.cpp:32: int v = car[i][2];//驶入速度
answers/GD-S03254/detect/detect.cpp:33: int a = car[i][3];//加速度
answers/GD-S03254/detect/detect.cpp:34: int b = -1; //超速起始点
answers/GD-S03254/detect/detect.cpp:35: int e = -1; //超速终点
answers/GD-S03254/detect/detect.cpp:79: car[i][6]=1; //被发现超速
answers/GD-S02779/detect/detect.cpp:15: float over[100005];//车辆刚好超速的位置
answers/GD-S02779/detect/detect.cpp:18: for(int i=0;i<n;i++){//车辆数据预处理
answers/GD-S02779/detect/detect.cpp:51: float ti[4]={-1,-1,L,-1};//匀速最晚入场 匀加最晚超速 匀减最早正常，匀减最晚入场
answers/GD-S00231/duel/duel.cpp:19: //1.最小卡被第二小卡“打死”
answers/GD-S00231/duel/duel.cpp:21: //有则重复上行为，没有则输出场上牌数
answers/GD-S00231/duel/duel.cpp:22: //都相等也输出
answers/GD-S00231/duel/duel.cpp:53: int ans = n;//总活卡初始为n
answers/GD-S00231/duel/duel.cpp:62: break;//如果全部相等，跳出循环
answers/GD-S00231/duel/duel.cpp:63: minn = cards[n - ans].number;//找最小值
answers/GD-S00231/duel/duel.cpp:76:// 找次小值 并转状态
answers/GD-S02499/detect/detect.cpp:5:struct dn{//分数结构体
answers/GD-S02499/detect/detect.cpp:6: int s,m;//m:分母，s:分子
answers/GD-S02499/detect/detect.cpp:17:struct up_car{//加速车辆
answers/GD-S02499/detect/detect.cpp:20: dn ost,osx;//超速时间，超速位移
answers/GD-S02499/color/color.cpp:9: dfs(t+1,sum+(a[rl]==a[t]?a[t]:0),t,bl);//染红
answers/GD-S02499/color/color.cpp:10: dfs(t+1,sum+(a[bl]==a[t]?a[t]:0),rl,t);//染蓝
answers/GD-S00564/duel/duel.cpp:7:int die;//记录被打死的怪兽个数
answers/GD-S00564/color/color.cpp:13:int dfs(string q,int idx,int cnt){//分别表示状态和填写到了idx这一位
answers/GD-S03046/duel/duel.cpp:6: int k,z;//k：攻击力和防御力，z：状态 (1为存活且未攻击过；0为攻击过；-1为出局)
answers/GD-S03046/color/color.cpp:5: int y;//颜色
answers/GD-S03046/color/color.cpp:6: int a;//数值
answers/GD-S03046/color/color.cpp:7: int c;//价值
answers/GD-S00202/arena/arena.cpp:24: if(l>n) tr[now]=(TREE){-1,0,l};//n以外，未知
answers/GD-S00202/arena/arena.cpp:25: else tr[now]=(TREE){a[l],l,0};//n以内，已知
answers/GD-S00202/arena/arena.cpp:39: if(tr[ls].fnw>=0){//擂主有已知
answers/GD-S00202/arena/arena.cpp:41: tr[now].fnw=tr[ls].fnw,tr[now].snw=tr[ls].snw;//擂台已知者必胜，确定胜者留在擂台
answers/GD-S00202/arena/arena.cpp:45: tr[now].fnw=tr[rs].fnw,tr[now].snw=tr[rs].snw;//擂台已知者必败，确定胜者可能来自客方
answers/GD-S00202/arena/arena.cpp:48: else{//擂主无已知
answers/GD-S00202/arena/arena.cpp:50: tr[now].fnw=tr[rs].fnw,tr[now].snw=tr[rs].snw;//擂台边没有已知者，确定胜者可能来自客方
answers/GD-S00202/arena/arena.cpp:57: tr[now].fnw=tr[rs].fnw,tr[now].snw=tr[rs].snw;//擂台已知者必胜
answers/GD-S00202/arena/arena.cpp:61: tr[now].fnw=tr[ls].fnw,tr[now].snw=tr[ls].snw;//擂台已知者必败
answers/GD-S00202/arena/arena.cpp:66: tr[now].fnw=tr[ls].fnw,tr[now].snw=tr[ls].snw;//擂台边没有已知者
answers/GD-S00202/arena/arena.cpp:76: if(r<=x) return tr[now];//全是确定东西
answers/GD-S00202/arena/arena.cpp:77: if(l>x) return (TREE){-1,0,h[r]-h[l-1]};//全是未知东西，全都能上
answers/GD-S00202/arena/arena.cpp:88: res.fnw=t1.fnw,res.snw=t1.snw;//擂台已知者必胜，确定胜者留在擂台
answers/GD-S00202/arena/arena.cpp:92: res.fnw=t2.fnw,res.snw=t2.snw;//擂台已知者必败，确定胜者可能来自客方
answers/GD-S00202/arena/arena.cpp:97: res.fnw=t2.fnw,res.snw=t2.snw;//擂台边没有已知者，确定胜者可能来自客方
answers/GD-S00202/arena/arena.cpp:104: res.fnw=t2.fnw,res.snw=t2.snw;//擂台已知者必胜
answers/GD-S00202/arena/arena.cpp:108: res.fnw=t1.fnw,res.snw=t1.snw;//擂台已知者必败
answers/GD-S00202/arena/arena.cpp:113: res.fnw=t1.fnw,res.snw=t1.snw;//擂台边没有已知者
answers/GD-S02649/detect/detect.cpp:91:ai=0 vi>V：所有pj>=di的j标记，如果存在j则超速
answers/GD-S02649/detect/detect.cpp:93:ai>0 vi>V：所有pj>=di的j标记，如果存在j则超速
answers/GD-S02649/detect/detect.cpp:94:ai>0 vi<=V：s=(V^2-vi^2)/(2ai)，所有pj>=di+s的j标记，如果存在j则超速
answers/GD-S02649/detect/detect.cpp:95:ai<0 vi>V：s=(V^2-vi^2)/(2ai)，所有pj>=di,pj<=di+s的标记，如果存在j则超速
answers/GD-S00103/detect/detect.cpp:4: int d;//距离最南端d的位置驶入
answers/GD-S00103/detect/detect.cpp:5: int v;//初速度v
answers/GD-S00103/detect/detect.cpp:6: int a;//加速度a;
answers/GD-S00103/detect/detect.cpp:16: int L;//主干道长度
answers/GD-S00620/detect/detect.cpp:63: int pos = 0; // 目前最靠右的测速仪
answers/GD-S00620/detect/detect.cpp:89:对于首先每辆车超速的段显然是一个区间
answers/GD-S00620/detect/detect.cpp:93:先对测速仪做一个前缀和
answers/GD-S00620/detect/detect.cpp:94:然后对于每个区间，求出区间内是否存在测速仪即可。
answers/GD-S00620/detect/detect.cpp:95:时间复杂度 O(n + m)
answers/GD-S00620/detect/detect.cpp:98:考虑只剩下超速的区间
answers/GD-S00620/detect/detect.cpp:99:首先先对区间按右端点排序
answers/GD-S00620/detect/detect.cpp:100:如果当前区间没有被前面的测速仪拿下，
answers/GD-S00620/detect/detect.cpp:101:那么贪心选择尽可能靠右的测速仪。
answers/GD-S00620/detect/detect.cpp:102:一个 log 完成
answers/GD-S00620/color/color.cpp:96:首先发现对于一种方案，
answers/GD-S00620/color/color.cpp:97:如果将所有数的颜色异或，
answers/GD-S00620/color/color.cpp:98:答案显然不会发生变化
answers/GD-S00620/color/color.cpp:100:考虑设 f[i][j] 表示考虑前 i 个数
answers/GD-S00620/color/color.cpp:101:其中钦定第 i 个颜色为红色，
answers/GD-S00620/color/color.cpp:102:然后最大的蓝色为 j 的最大价值
answers/GD-S00620/color/color.cpp:104:那么给 i 贡献的显然是 i - 1，从 f[i - 1][j] 转移
answers/GD-S00620/color/color.cpp:105:否则枚举 k，从 f[i - 1][k] 转移
answers/GD-S00620/color/color.cpp:106:这样我们已经有了一个 n ^ 2 做法
answers/GD-S00620/color/color.cpp:108:状态决定一切
answers/GD-S00620/color/color.cpp:109:先滚动掉第一维
answers/GD-S00620/color/color.cpp:112:考虑贡献和值而不是位置有关，
answers/GD-S00620/color/color.cpp:113:所以我们把下标换成值。
answers/GD-S00620/color/color.cpp:114:值有点大，先离散化一下
answers/GD-S00620/color/color.cpp:116:g[v] 表示 a[j] = v 中的 f[i][j] 的最大值
answers/GD-S00620/color/color.cpp:117:如果没有就是 -infty
answers/GD-S00620/color/color.cpp:119:opt1 就是对于 g[a[i]] 和 g[!a[i]] 取个 max
answers/GD-S00620/color/color.cpp:122:那么线段树即可
answers/GD-S00620/arena/arena.cpp:95:这下素质低下了
answers/GD-S00620/arena/arena.cpp:97:感觉正解就是线性做法吗
answers/GD-S00620/arena/arena.cpp:99:首先把询问离线，排序来做。
answers/GD-S00620/arena/arena.cpp:100:对于每个人，我们都可以用一个实力区间来表示
answers/GD-S00620/arena/arena.cpp:101:对于不确定的人就是 [0, U]
answers/GD-S00620/arena/arena.cpp:102:对于确定的人就是 [ai, ai]
answers/GD-S00620/arena/arena.cpp:103:用结构体 node 表示
answers/GD-S00620/arena/arena.cpp:107:看错题了啊啊啊
answers/GD-S00190/detect/detect.cpp:6:int n,m,L,cam[maxn],T,ans,ans2;//车数,测数,长度,摄像头位置 ,是否有摄像头 ,q1.top().second.second==0,答案
answers/GD-S00190/detect/detect.cpp:10: double d,v,a;//进入点,速度,加速度
answers/GD-S00190/detect/detect.cpp:55:priority_queue<pair<double,pair<double,int> > > q1,q2;//q2first为-r,second为l,q1first为-l,second为r ,1左开,0右开 ，-1不开
answers/GD-S03195/detect/detect.cpp:9:/*int car[3005];//发现其超速的摄像头数
answers/GD-S03195/detect/detect.cpp:10:struct node{//摄像头发现超速车辆数
answers/GD-S03195/detect/detect.cpp:14:int map[3005][3005];//对应关系,前为车，后为摄像头
answers/GD-S03195/detect/detect.cpp:25: //t组：不重输入，要再初始化
answers/GD-S03195/detect/detect.cpp:27: //重新初始化
answers/GD-S03195/detect/detect.cpp:42: if(dx >= 0 && (a[i] >= 0 ||(a[i] < 0 && 2*a[i]*dx >= -v[i]*v[i]))){//是否还在运动
answers/GD-S03195/detect/detect.cpp:43: //超速否
answers/GD-S03195/duel/duel.cpp:13: //贪心
answers/GD-S03195/duel/duel.cpp:17: if(r[i] > r[dis]) dis++,beat++;//能打过，弱者退出，并给下一怪
answers/GD-S03195/duel/duel.cpp:18: //(打不过， dis保持，轮到 下一怪 )
answers/GD-S03195/color/color.cpp:10: //注意初始化问题
answers/GD-S03477/color/color.cpp:7:int T, n, a[MAXN]; LL dp[2][2][2][MAXN], que[MAXN]; // 记录i与前一个数同色的贡献，求前缀和
answers/GD-S03477/color/color.cpp:8:int aij[MAXN], ta[MAXA]; // 记为左边第一个一样的数
answers/GD-S03477/color/color.cpp:25: for (int i = 1; i<=n; i++) // 可以查询有用
answers/GD-S03477/color/color.cpp:30: // 先做0的 dp[自己(绝对值)][前辈(一致性)][朋友(一致性)][下标]
answers/GD-S03477/color/color.cpp:31: // 考虑与朋友和前辈都不一样
answers/GD-S03477/color/color.cpp:34: // 考虑与前辈一样
answers/GD-S03477/color/color.cpp:37: // 考虑与朋友一样，除非朋友就是前辈，否则与前辈肯定不一样
answers/GD-S03477/color/color.cpp:40: // 考虑区间第一个数fr+1，可能有贡献
answers/GD-S03477/color/color.cpp:42: if (fr == i-1) { // 前辈就是朋友
answers/GD-S03477/color/color.cpp:43: dp[j][0][1][i] += (LL)a[i]; // 与朋友的区间贡献
answers/GD-S03477/color/color.cpp:46: dp[j][0][1][i] += (que[i-1]-que[fr+1])+(LL)a[i]; // 与朋友的区间贡献
answers/GD-S03477/color/color.cpp:51: } else { // 没朋友于是继承
answers/GD-S00514/arena/arena.cpp:8:// 是否存在自由人，答案的和
answers/GD-S01544/detect/detect.cpp:6://颜...我们刚认识 甚至称不上是朋友，但我觉得你好好看，有好多优点...我可能，可能哈...喜欢你
answers/GD-S01544/detect/detect.cpp:34: //至此还剩：v <= vt and a > 0 / v > vt and a < 0
answers/GD-S01544/detect/detect.cpp:120: update(k + 1);//树状数组值域向右挪一位给0
answers/GD-S01587/detect/detect.cpp:11:// 超速区间，如果 l = r = 0 则不超速
answers/GD-S01587/detect/detect.cpp:39: // 摄像头前缀和
answers/GD-S01587/detect/detect.cpp:44: // 整理出所有车辆的超速区间
answers/GD-S01587/detect/detect.cpp:61: l[t][i] = carD[t][i] + x11 / x22 + 1; // 左边开区间，要+1转为闭区间
answers/GD-S01587/detect/detect.cpp:67: r[t][i] = carD[t][i] + x11 / x22 - 1; // 右边开区间，要-1转为闭区间
answers/GD-S01587/detect/detect.cpp:75: l[t][i] = carD[t][i] + x11 / x22 + 1; // 左开区间，向上取整+1
answers/GD-S01587/detect/detect.cpp:81: r[t][i] = carD[t][i] + x11 / x22; // 右开区间，向下取整转为闭区间
answers/GD-S01587/detect/detect.cpp:89: // 根据摄像头前缀和，看看有几个车被检测到超速
answers/GD-S01587/detect/detect.cpp:92: // 没有超速
answers/GD-S01587/detect/detect.cpp:96: // 有摄像头
answers/GD-S02793/detect/detect.cpp:41:// cout<<ans<<" "<<m-1<<endl; 这个坑点
answers/GD-S02275/color/color.cpp:5:int b[N];//原数组
answers/GD-S02275/color/color.cpp:15:int c[N];//原->排好的
answers/GD-S01878/detect/detect.cpp:56: if(a<0) {//速度一直减小
answers/GD-S01878/detect/detect.cpp:67: }else {//速度一直增大
answers/GD-S03249/detect/detect.cpp:82: return false; //若该摄像头在该车的停止位置之后
answers/GD-S01352/detect/detect.cpp:5: cin>>a>>b>>c>>d;//车辆数量、测速仪数量、主干道长度和道路限速。
answers/GD-S00862/detect/detect.cpp:16:bool cmr(int lq,int lp,int rq,int rp){//(lq/lp,rq/rp)的范围内是否有摄像头 记得把分子分母设为正数
answers/GD-S00862/detect/detect.cpp:99:bool pht(long long k,long long st,long long v,long long a){//第k个摄像头
answers/GD-S03199/detect/detect.cpp:9://涉及到数值的请均用double
answers/GD-S03199/detect/detect.cpp:15:int dloc[ML] = {}; //测速仪的前缀和数组
answers/GD-S03199/detect/detect.cpp:41: double point = d + (V*V - v*v) / (2.0 * a); //计算速度什么时候达到 V
answers/GD-S03199/detect/detect.cpp:58: for(int i=1; i<=n; ++i){ //计算每个车辆涉及到多少测速仪, 涉及到了哪几个
answers/GD-S03199/detect/detect.cpp:67: sort(box+1, box+cntbox+1, cmp); //整理木板
answers/GD-S02147/detect/detect.cpp:12:/*匀加速运动 是指物体在运动过程中，加速度保持不变的运动，即每单位时间内
answers/GD-S02147/detect/detect.cpp:13:速度的变化量是恒定的。
answers/GD-S02147/detect/detect.cpp:14:. 当一辆车的初速度为v0、加速度a .= 0，做匀加速运动，则t 时刻后它的速度
answers/GD-S02147/detect/detect.cpp:15:v1 = v0 + a × t，它的位移（即行驶路程）s = v0 × t + 0.5 × a × t2。
answers/GD-S02147/detect/detect.cpp:16:. 当一辆车的初速度为v0、加速度a .= 0，做匀加速运动，则当它的位移（即行驶
answers/GD-S02147/detect/detect.cpp:17:路程）为s 时，这辆车的瞬时速度为
answers/GD-S02147/detect/detect.cpp:21:. 当一辆车的初速度为v0、加速度a .= 0，在它的位移（即行驶路程）为v2
answers/GD-S02147/detect/detect.cpp:26:时，
answers/GD-S02147/detect/detect.cpp:27:这辆车的瞬时速度为v1。*/
answers/GD-S00242/detect/detect.cpp:114:迷惑行为*2
answers/GD-S00242/detect/detect.cpp:116:Omg it's 大模拟！I Love you CCF!
answers/GD-S00242/duel/duel.cpp:48:迷惑行为启动！
answers/GD-S00242/duel/duel.cpp:50:上午 J 组预估2=，来 S 组玩玩。
answers/GD-S00242/duel/duel.cpp:52:妈耶……一道题也不会……
answers/GD-S00242/duel/duel.cpp:54:算了只好使用骗分大法了！
answers/GD-S00242/duel/duel.cpp:56:T1 的前 4 个测试点都很小，直接 dfs！期望得分 ：0-20
answers/GD-S00242/duel/duel.cpp:58:T2……wc还好我提前学过高中物理必修1！……还是不会做……
answers/GD-S00242/duel/duel.cpp:60:算了，瞄准a=0、a>0和a<0的6个测试点，直接单独讨论！期望得分：10-60
answers/GD-S00242/duel/duel.cpp:62:T3 本来有点贪心的思路的，结果写到后面写无语了，换成了只能过样例的离谱骗分。期望得分：0
answers/GD-S00242/duel/duel.cpp:64:T4 不会，期望得分：0
answers/GD-S00242/duel/duel.cpp:66:期望最高得分：20+60+0+0=80
answers/GD-S00242/duel/duel.cpp:68:除非今年水军特多导致分数线极低，否则……
answers/GD-S00242/color/color.cpp:31:迷惑行为*3
answers/GD-S00242/arena/arena.cpp:12:什么？你问我为什么输出样例？
answers/GD-S00242/arena/arena.cpp:14:因为我不会。（坦诚
answers/GD-S00242/arena/arena.cpp:16:芜湖！S组成功败北！
answers/GD-S02608/color/color.cpp:17://fi,0/1:i为右端点，且i-1为空/不为空
answers/GD-S02083/detect/detect.cpp:8: int a;//d：初始位置 v：初速度 a:加速度
answers/GD-S02083/detect/detect.cpp:34: cin>>n>>m>>L>>V;//n, m, L, V ，分别表示车辆数量、测速仪数量、主干道长度和道路限速。
answers/GD-S01475/detect/detect.cpp:12: int sum = 0; //一开始就超速
answers/GD-S03219/detect/detect.cpp:21://根据距南远近排序
answers/GD-S03219/detect/detect.cpp:53: //文件操作，不要忘记删掉注释
answers/GD-S03219/detect/detect.cpp:60: //初始化数组
answers/GD-S03219/detect/detect.cpp:77: //特殊性质A(小数据)
answers/GD-S03219/detect/detect.cpp:80: //车和检测器的顺序对答案无影响，可以直接排序
answers/GD-S03219/duel/duel.cpp:17: //文件操作，记得删掉注释
answers/GD-S03219/duel/duel.cpp:21: //初始化数组
answers/GD-S03219/duel/duel.cpp:35: //将r[i]从小到大排序
answers/GD-S03219/duel/duel.cpp:37: //如果全都是1、2的话，可以直接快速计算
answers/GD-S03219/duel/duel.cpp:43: //否则就利用last指针来快速打怪兽
answers/GD-S03219/color/color.cpp:13: //文件操作，不要忘记删掉注释
answers/GD-S03219/arena/arena.cpp:9: //文件操作，不要忘记删掉注释
answers/GD-S00319/detect/detect.cpp:12: cin>>a[i]>>b[i]>>c[i]; //a为起始点，b为原速度，c为加速速度
answers/GD-S00964/detect/detect.cpp:89: bb[i].push_back(j);//i监控看到j车
answers/GD-S00964/detect/detect.cpp:90: bs[j].push_back(i);//j车被i监控看到
answers/GD-S02006/detect/detect.cpp:10:int nearDetect[MAXNUM*10];//最近的测速仪
answers/GD-S02006/detect/detect.cpp:14:/* ！！返回末速度的平方！！ */
answers/GD-S02006/detect/detect.cpp:15:int getVfang(int k,int dis)//第k辆车，行驶了dis距离
answers/GD-S03331/duel/duel.cpp:8: int dat,t,atta;//t表示剩余怪兽数量,atta表示所剩攻击数
answers/GD-S00593/detect/detect.cpp:12: int v;//初始速度
answers/GD-S00593/detect/detect.cpp:13: int a;//加速度
answers/GD-S00593/detect/detect.cpp:19:int nar[maxl];//nar[i]表示离 i 最近的下一个测速仪
answers/GD-S00593/detect/detect.cpp:25: //预处理
answers/GD-S00593/detect/detect.cpp:33: //每辆车的元素
answers/GD-S00593/detect/detect.cpp:35: //处理每个位置 i 的下一个测速仪的位置
answers/GD-S00593/detect/detect.cpp:45: //若它是加速的
answers/GD-S00593/detect/detect.cpp:47: //那么在这辆车经过最后一个测速仪 p_m 之前
answers/GD-S00593/detect/detect.cpp:48: //它的速度超过了 v 则可以将其判定为超速
answers/GD-S00593/detect/detect.cpp:53: //若它是减速的
answers/GD-S00593/detect/detect.cpp:55: //那么在这辆车通过离它最近的测速仪之前
answers/GD-S00593/detect/detect.cpp:56: //他的速度并没有降至 v 以下则可以将其判定为超速
answers/GD-S00593/detect/detect.cpp:64: //一是 l ，即超速区间的左端点
answers/GD-S00593/detect/detect.cpp:69: //二是 r ，即超速区间的右端点
answers/GD-S00593/detect/detect.cpp:72: //若它是匀速的
answers/GD-S00593/detect/detect.cpp:74: //那么它的初始速度如果超过 v 则可以将其判定为超速
answers/GD-S00593/detect/detect.cpp:83: //是否需要弹出
answers/GD-S00593/detect/detect.cpp:85: //第一个值表示其的位置
answers/GD-S00593/detect/detect.cpp:86: //第二个值表示其类型，编号的索引
answers/GD-S00593/detect/detect.cpp:89: //如果它是右端点则加入
answers/GD-S00593/detect/detect.cpp:93: //如果它是左端点且在队列里面则弹出
answers/GD-S00593/detect/detect.cpp:121://我爱你ccf
answers/GD-S00593/detect/detect.cpp:122://给点部分分行不
answers/GD-S00593/detect/detect.cpp:123://我写了三个小时qwq
answers/GD-S00593/color/color.cpp:10: //红色是0，蓝色是1
answers/GD-S02945/detect/detect.cpp:21: long long n,m,v;//n辆车，m个测速仪，主干道长l，限速v
answers/GD-S02945/detect/detect.cpp:24: int di[11451],vi[11451],ai[11451];//di处驶入，初速度vi，加速度ai
answers/GD-S02945/detect/detect.cpp:25: for(register long long i=1;i<=n;i++){//一行一辆车
answers/GD-S02945/detect/detect.cpp:41: //每车枚举计算
answers/GD-S02945/detect/detect.cpp:43: //特判成立
answers/GD-S02945/detect/detect.cpp:57: //可删除的测速仪
answers/GD-S02945/detect/detect.cpp:60: register long long sovsd=0;//瞬时时速计数
answers/GD-S02945/detect/detect.cpp:67: p[k]==-1;//删
answers/GD-S02945/detect/detect.cpp:73: //可删除的测速仪计数
answers/GD-S02945/duel/duel.cpp:6:int kill[11451]={0};//最终存活怪兽，0表示活着，1表示攻击过，2表示退出
answers/GD-S02945/duel/duel.cpp:14: //为怪兽战力排序，如果哪个高就杀前一个比它低的
answers/GD-S02945/duel/duel.cpp:22: //战斗
answers/GD-S02945/duel/duel.cpp:26: kill[i-j]=2;//退出
answers/GD-S02189/detect/detect.cpp:111: //我只要知道最短的那个
answers/GD-S01388/detect/detect.cpp:158://16:17 拼完暴力了，158行
answers/GD-S01388/duel/duel.cpp:26:}//14:55签到
answers/GD-S01102/detect/detect.cpp:17: for(int i=1;i<=m;i++){ //对于每一个测试仪 ,得出可测超速车辆
answers/GD-S01102/arena/arena.cpp:52: }for(int i=1;i<=m;i++){ //对于每一个测试仪 ,得出可测超速车辆
answers/GD-S02008/detect/detect.cpp:71:到达某时间t的瞬间的位移量=初速度*t+(2/1)*加速度*t的平方
answers/GD-S02008/detect/detect.cpp:72:到达某位移量s瞬间的速度=sqrt(初速度的平方+2*加速度*s)
answers/GD-S02008/detect/detect.cpp:73:位移量=瞬间速度的平方-初速度的平方/2*加速度
answers/GD-S02008/duel/duel.cpp:5:int a[N];//0活着 -1退出游戏 1已经发起攻击
answers/GD-S01541/detect/detect.cpp:13: scanf("%d%d%d%d", &n, &m, &s, &V);//车的数量，监测仪的数量，路的长度，限速
answers/GD-S01541/detect/detect.cpp:28: }//记录每一辆车超速区间
answers/GD-S01541/detect/detect.cpp:35: }//哪些车被检测超速
answers/GD-S01541/detect/detect.cpp:41: }//如果有一段区间被完全包含，那么包含他的区间可以忽略不计。
answers/GD-S01541/detect/detect.cpp:46: }//贪心区间用最后一块测速仪
answers/GD-S00304/duel/duel.cpp:18: }//找出最小和最大攻击力，桶装
answers/GD-S00304/duel/duel.cpp:24: if(b[i]>r[i-1])//前面不够分
answers/GD-S02057/detect/detect.cpp:4:int n,m,L,V; //车 测速仪数量 主干道长度 限速
answers/GD-S02057/detect/detect.cpp:8: int d,v,a; //初始距离 初速度 加速度
answers/GD-S02057/detect/detect.cpp:11:bool ecar[M]; //是否有车经过
answers/GD-S02057/detect/detect.cpp:13:// 原始 目标 加速
answers/GD-S02057/detect/detect.cpp:14:double calc_speed(int v_ori,int v_tgt,int v_u){ //计算超速时候的行驶路程
answers/GD-S02057/detect/detect.cpp:42: if(cur.v > V && cur.d <= sp[m]) { //最后测试仪之前
answers/GD-S02057/detect/detect.cpp:49: // 加速的情况
answers/GD-S02057/detect/detect.cpp:51: // 浮点数比较
answers/GD-S02057/detect/detect.cpp:52: if(ups_lc + (double)cur.d > (double) sp[m]){ //最后一个测速仪了
answers/GD-S02057/detect/detect.cpp:60: //减速的情况
answers/GD-S02057/duel/duel.cpp:6:int b[N]; //离散化后数组
answers/GD-S02057/duel/duel.cpp:7:int ft[N]; //前缀和
answers/GD-S02057/duel/duel.cpp:10:int modify = 0; //修正当前前缀和
answers/GD-S02057/duel/duel.cpp:19: // 离散化 然后尝试往后遍历 查看是否有至少一个比他小的用于匹配？
answers/GD-S02057/duel/duel.cpp:20: // 前缀和？
answers/GD-S02057/duel/duel.cpp:21: // 不管了先排个序
answers/GD-S02057/duel/duel.cpp:38: int c = ft[i-1] - modify; //还剩多少个可以杀
answers/GD-S02057/duel/duel.cpp:44: // 保证不为零
answers/GD-S02057/arena/arena.cpp:13://注意所有和X有关的运算都要转ll
answers/GD-S01137/detect/detect.cpp:10: double l,r;//l,r指哪一段区间会超速
answers/GD-S01137/detect/detect.cpp:43: }//预处理超速区间
answers/GD-S01137/detect/detect.cpp:48: if(q<=w-1){//如果超速区间中夹着至少一个测速仪，answer++
answers/GD-S01226/detect/detect.cpp:25: //左闭右开2
answers/GD-S01226/detect/detect.cpp:26: //左开右闭3
answers/GD-S00569/color/color.cpp:22: if(c[now]==1) //1为blue
answers/GD-S00569/color/color.cpp:31: else if(c[now]==2) //2为red
answers/GD-S01745/detect/detect.cpp:5:口胡一种新做法：
answers/GD-S01745/detect/detect.cpp:6:直接预处理好每一个车车的超速区间 时间 O(n)
answers/GD-S01745/detect/detect.cpp:8:然后对一个车 i 考虑直接二分去找大于等于 l 的第一个测速仪
answers/GD-S01745/detect/detect.cpp:9:直接判断测速仪位置是否小于 r 即可
answers/GD-S01745/detect/detect.cpp:10:这样子直接做第一问就行 时间 O(nlogm)
answers/GD-S01745/detect/detect.cpp:12:对于第二问来说，考虑贪心选最少的测速仪
answers/GD-S01745/detect/detect.cpp:13:先把能检测出 超速的 提出来弄成新数组
answers/GD-S01745/detect/detect.cpp:14:然后对车的超速区间 r 从小到大排序
answers/GD-S01745/detect/detect.cpp:15:对于超速车 i 来说，有几种情况：
answers/GD-S01745/detect/detect.cpp:16:1.区间内没有测速仪，判断：用 l 跟最后一个选的测速仪比较
answers/GD-S01745/detect/detect.cpp:17: 做法：二分查找小于等于 r 的测速仪，选它，ans2++
answers/GD-S01745/detect/detect.cpp:18:2.区间内有测速仪：直接跳过
answers/GD-S01745/detect/detect.cpp:19:时间:O(n+nlogm)
answers/GD-S01745/detect/detect.cpp:20:总时间：O(n+2nlogm) 感觉能行
answers/GD-S01745/detect/detect.cpp:22:考场手调 2.7h 没看见 d 能是 0
answers/GD-S01745/detect/detect.cpp:23:不写 flag判断
answers/GD-S01745/detect/detect.cpp:24:催泪了 幸好眼睛关键时候发挥作用
answers/GD-S01745/detect/detect.cpp:41:// 处理出超速区间 [l,r] -> 保证 l,r 为整数且此时速度严格大于限速 V
answers/GD-S01745/detect/detect.cpp:64: int x=(V*V-car[id].v*car[id].v)/2/car[id].a+1; // 要走 x 才能超速
answers/GD-S01745/detect/detect.cpp:89:int search1(int x) // 二分找第一个大于等于 x 的 p[i]
answers/GD-S01745/detect/detect.cpp:105:int search2(int x) // 二分找最后一个小于等于 x 的 p[i]
answers/GD-S01745/duel/duel.cpp:5:r[i] 先从小到大排序
answers/GD-S01745/duel/duel.cpp:6:直接贪心秒
answers/GD-S01745/duel/duel.cpp:7:显然让它打前面的那只，判断能不能打赢就行
answers/GD-S01745/duel/duel.cpp:8:但是要考虑枚举顺序，显然应该从菜的开始
answers/GD-S01745/duel/duel.cpp:9:直接让 i 打当前最菜的就行
answers/GD-S01745/duel/duel.cpp:29: if(r[i]>r[j]) // 能打过，直接秒
answers/GD-S01745/color/color.cpp:4:// 想都不想 直接暴力打满 1 2 3 4 拿 20 pts
answers/GD-S01745/arena/arena.cpp:3:// 逆天题目 写不了一点啊
answers/GD-S02481/detect/detect.cpp:52: for(int j=1;j<=n;j++)//清零开始
answers/GD-S02481/detect/detect.cpp:62: cntt=0;//到此结束
answers/GD-S02481/detect/detect.cpp:66:}//只得20分应该
answers/GD-S01963/detect/detect.cpp:5:int T;//记得清空
answers/GD-S01963/detect/detect.cpp:33:line work1(int i,int pos)//处理加速度大于0的情况
answers/GD-S01963/detect/detect.cpp:50:line work2(int i,int pos)//处理加速度小于0的情况
answers/GD-S01479/arena/arena.cpp:7: //真的不会，一点都不会，要爆0了
answers/GD-S01479/arena/arena.cpp:8: //如果是有迷惑行为大赏的务必把我放上去
answers/GD-S01479/arena/arena.cpp:9: //我喜欢喜多郁代！！！！
answers/GD-S01479/arena/arena.cpp:10: //超级喜欢
answers/GD-S01479/arena/arena.cpp:11: //还有二十分钟了我这题目一点思路都没有
answers/GD-S02169/detect/detect.cpp:2:对于每一辆车考虑在速度达到 V 时，开出去多远
answers/GD-S02169/detect/detect.cpp:3:如果 a<=0 且 v<=V 那么 一定不会超速
answers/GD-S02169/detect/detect.cpp:4:如果 v>V 且 a>=0 那么一定超速
answers/GD-S02169/detect/detect.cpp:5:其他的直接算速度达到 V 时，位移
answers/GD-S02169/detect/detect.cpp:6:算时间，然后用平均速度
answers/GD-S02169/detect/detect.cpp:8:每一辆超速的车相当于约束出来某一段区间必须有测速仪
answers/GD-S02169/detect/detect.cpp:9:把区间取出来贪一下就是第二问
answers/GD-S02169/detect/detect.cpp:11:是否需要离散化仍未知
answers/GD-S02169/detect/detect.cpp:12:写完之后跑极限数据
answers/GD-S02169/detect/detect.cpp:14:车子速度变化到 V 所用时间 t=(V-v[i])/a[i]
answers/GD-S02169/detect/detect.cpp:15:跑的距离 s=(v+V)/2*t
answers/GD-S02169/detect/detect.cpp:17:这个判超速的机制很神奇，必须要遇到测速仪才算超速
answers/GD-S02169/detect/detect.cpp:19:改成了 longdouble
answers/GD-S02169/detect/detect.cpp:35://cnt[pos] 表示 pos 位置上有多少个测速仪
answers/GD-S02169/detect/detect.cpp:36://大概这个是要跑后缀和的
answers/GD-S02169/detect/detect.cpp:37://cnt[pos] 表示区间 [pos,L] 里面有多少个测速仪，包括端点
answers/GD-S02169/detect/detect.cpp:56: //记录某一辆车是否超速
answers/GD-S02169/detect/detect.cpp:60: //这个区间还要转化一下
answers/GD-S02169/detect/detect.cpp:89: if(x[i].d+s-L>eps){//车子速度变化到 V 之前已经离开道路
answers/GD-S02169/detect/detect.cpp:90: //如果这个车子一开始的速度就是大于 V 的话，那么只要这一段后缀区间里面有测速器，就会超速
answers/GD-S02169/detect/detect.cpp:99: //那么现在我们考虑的是这个车子速度变化到 V 时，还未离开道路
answers/GD-S02169/detect/detect.cpp:100: //记现在算出来的超速位置为 pos
answers/GD-S02169/detect/detect.cpp:101: //如果这个车子的速度 <=V，那么只要在 (pos,L] 里面有测速仪，这个车子就超速
answers/GD-S02169/detect/detect.cpp:102: //否则在 [d[i],pos] 里面有测速仪，这个车子才算超速
answers/GD-S02169/detect/detect.cpp:103: //把这些区间都存下来，拿去跑第二问的贪心
answers/GD-S02169/detect/detect.cpp:107: if(x[i].d+s-pos<=eps){ //如果速度变化到 V 的位置恰好是一个整点，那么要考虑前面一位的位置
answers/GD-S02169/detect/detect.cpp:109: }//调出来了，要翻盘了！
answers/GD-S02169/color/color.cpp:31: //f[i][j] 表示前 i 个数，上一个颜色段的结尾为 j ，钦定当前段结尾为 i 的最大收益
answers/GD-S00733/detect/detect.cpp:22:pair<int,int> q[H];//一定记住先r再l
answers/GD-S00733/detect/detect.cpp:52: if(cr[i].a>=0){//找第一次超速的点
answers/GD-S00733/detect/detect.cpp:64: }else{//找最后一次超速的点
answers/GD-S00733/arena/arena.cpp:10:pair<long long,long long> ask[H];//第一项表示询问，第二项表示这是第几个询问
answers/GD-S00120/detect/detect.cpp:68: if(!yes){ //a全不为0
answers/GD-S01933/detect/detect.cpp:9: //可恶的check2!
answers/GD-S01711/arena/arena.cpp:17: for (int i=1;i<=k;i++){//大轮次
answers/GD-S01711/arena/arena.cpp:18: for (int j=1;j<=(1<<k-i);j++)//小回合,2j-1和2j打
answers/GD-S02668/duel/duel.cpp:10: //记录未死卡牌数
answers/GD-S02668/duel/duel.cpp:12: //游戏检测的变量(为1即结束游戏)
answers/GD-S02668/duel/duel.cpp:14: //防御最小的卡牌s
answers/GD-S02668/duel/duel.cpp:18: //是否攻击或死亡(不攻击：1 已攻击：0 死亡：-1)
answers/GD-S02668/duel/duel.cpp:21: //卡牌及输入及生命与攻击次数初始化
answers/GD-S02668/duel/duel.cpp:29: //循坏
answers/GD-S02668/duel/duel.cpp:33: //最小卡牌计数
answers/GD-S02668/duel/duel.cpp:35: //找最小值
answers/GD-S02668/duel/duel.cpp:44: //获取所有最小卡牌及其下标
answers/GD-S02668/duel/duel.cpp:55: //攻击所有最小卡片
answers/GD-S02668/duel/duel.cpp:58: //g用于记录最小差值
answers/GD-S02668/duel/duel.cpp:60: //找到进行攻击的最优卡牌
answers/GD-S02668/duel/duel.cpp:70: //检测是否还能继续游戏
answers/GD-S02668/duel/duel.cpp:81: //检测游戏是否结束
answers/GD-S03468/detect/detect.cpp:12://上面是A特殊的变量，下面是B特殊；
answers/GD-S03468/detect/detect.cpp:16://上面是B特殊的变量，下面是C特殊；
answers/GD-S03468/detect/detect.cpp:78:这里还是Coverain
answers/GD-S03468/detect/detect.cpp:79:不想给Exp10re打广告了但是他真的很爱他的线段树老婆
answers/GD-S03468/detect/detect.cpp:80:是时候让评测机吃点屎了！
answers/GD-S03468/detect/detect.cpp:81:我打了四个特殊性质的点 希望CCF保佑我能至少对一个
answers/GD-S03468/duel/duel.cpp:23:这里是Coverain洛谷同名
answers/GD-S03468/duel/duel.cpp:24:Exp10re这个noob在隔壁考试（洛谷同名红名大佬）
answers/GD-S03468/duel/duel.cpp:25:他老婆是线段树
answers/GD-S03468/duel/duel.cpp:26:他让我打这个注释为他的老婆打call
answers/GD-S03468/duel/duel.cpp:27:CCF保佑我不爆零
answers/GD-S03468/color/color.cpp:37: //若取1
answers/GD-S03468/color/color.cpp:50: //若取0
answers/GD-S03468/color/color.cpp:74:现在还剩下34分钟 Coverain连第三题的暴力打法都没想出来
answers/GD-S03468/color/color.cpp:75:那就好好打几个注释发发牢骚罢
answers/GD-S03468/color/color.cpp:76:首先是Exp10re与他的线段树 孩子们他这辈子就这样了
answers/GD-S03468/color/color.cpp:77:我这些注释真的有人会去看吗 感觉Exp让我干这种事挺没用的
answers/GD-S03468/color/color.cpp:78:我印象中只有Noip中他们打的注释才会有人关注
answers/GD-S03468/color/color.cpp:79:而我这种蓝名估计瞄都不会瞄
answers/GD-S03468/color/color.cpp:80:好想多骗一点分啊但是都是多个测试点好难骗到分啊
answers/GD-S03468/color/color.cpp:82:嗯嗯写到这一行的时候只剩30分钟了 还好我在开始写这段文字的时候就已经上了厕所(*^▽^*)
answers/GD-S03468/color/color.cpp:83:现在感觉来考csp-s复赛都是神人啊 我是因为最后的5A级景区才卡线进来的（60就过线5分）
answers/GD-S03468/color/color.cpp:84:我现在寄希望于第一第二题不爆零 我拿他给的测试点都测试了 答案都对但估计tle
answers/GD-S03468/color/color.cpp:86:如果真有人无聊到csp结束之后看了我这段话还特意找了我的成绩 我只能说：
answers/GD-S03468/color/color.cpp:89:好了剩下20分钟 Coverain要去打最后一题了
answers/GD-S03468/color/color.cpp:91:剩下17分钟 Coverain连最后一题的输入都没搞明白
answers/GD-S03468/color/color.cpp:93:CCF求你别让我爆零
answers/GD-S03468/arena/arena.cpp:13:这里还是Coverain啊
answers/GD-S03468/arena/arena.cpp:15:教练看了这个估计也不会说啥罢 他对我的目标是不爆零就好诶
answers/GD-S03468/arena/arena.cpp:16:应该没事吧
answers/GD-S02601/arena/arena.cpp:78: if(mi[o<<1|d[o]]>=lun) //擂主赢
answers/GD-S02601/arena/arena.cpp:111: if(uncor[o<<1|d[o]]==0) //胜负已定
answers/GD-S02601/arena/arena.cpp:113: if(mi[o<<1|d[o]]>=lun) //擂主赢
answers/GD-S02601/arena/arena.cpp:168: //可赢可输
answers/GD-S02601/arena/arena.cpp:180:// if(dp.first^dp.second) //状态不一样
answers/GD-S02601/arena/arena.cpp:184:// if(dp.first) //还能活着
answers/GD-S02188/detect/detect.cpp:7: int pos;//位置
answers/GD-S02188/detect/detect.cpp:8: bool flag=false; //是否检查到超速
answers/GD-S02188/detect/detect.cpp:27: vector<radar> B(m);//测速仪位置
answers/GD-S03049/duel/duel.cpp:12:// a[i] 表示攻击力为i的怪物中能拿来攻击的卡牌数量
answers/GD-S03049/duel/duel.cpp:13:// c[i] 表示攻击力为i的怪物还剩几只
answers/GD-S00343/detect/detect.cpp:36: // a 表示 0
answers/GD-S00343/detect/detect.cpp:37: // b 表示 全部-
answers/GD-S00343/detect/detect.cpp:38: // c 表示 全部+
answers/GD-S01935/detect/detect.cpp:5: int d,v,a;//d开始位置，v初速度，a加速度
answers/GD-S01935/detect/detect.cpp:19: int cnt1,cnt2;//1所有都开启，2不漏最多关几个
answers/GD-S01935/color/color.cpp:13://用结构体记录此数前面是否有过，并用前缀和将c加起来，这是O（TN）？
answers/GD-S00907/detect/detect.cpp:4:对于加速度为0的车，只需要留下后面的就可以
answers/GD-S00907/detect/detect.cpp:5:对于加速度小于0车，需要找到离他最近的
answers/GD-S00907/detect/detect.cpp:6:加速度大于0，就需要找到离他最远的
answers/GD-S00907/detect/detect.cpp:7:但是有开根号的问题，可以尝试用sqrtl?
answers/GD-S00907/detect/detect.cpp:8:如果速度过大的话也不用管
answers/GD-S00907/detect/detect.cpp:9:速度其实好处理，而且如果过大的话记得要向下搞，也不会出现越界的情况
answers/GD-S00907/detect/detect.cpp:10:车的数量有点多，可能需要O1判断？
answers/GD-S00907/detect/detect.cpp:11:log可以过，那么可以离散化+二分，二分是为了求出能检测的区间
answers/GD-S00907/detect/detect.cpp:12:第二个问题就是求重要点，这个点应该包含尽可能多的区间，让其他的区间失去效果
answers/GD-S00907/detect/detect.cpp:13:贪心的处理，排序之后每次调用r处的测速仪，当然r可能对后面有影响，那么就提前标记这个点，然后如果l小于这个值就判断无效
answers/GD-S00907/detect/detect.cpp:26:bool check(long long x,long long y){//车和测速点
answers/GD-S00907/detect/detect.cpp:46: //多测记得清空！！！！！
answers/GD-S00907/detect/detect.cpp:56: if(a[i]==0){//注意是超过！！！
answers/GD-S00907/detect/detect.cpp:60: long long x=upper_bound(p+1,p+1+m,d[i])-p;//x可能大于m,因为可能这之后都没有检测的
answers/GD-S00907/detect/detect.cpp:71: while(dl<dr){//看看要不要取等号，因为可能都不能检测到
answers/GD-S00907/detect/detect.cpp:84: while(dl<dr){//看看要不要取等号，因为可能都不能检测到
answers/GD-S00907/detect/detect.cpp:94: //记得要可能要修改的二分ans1
answers/GD-S00907/color/color.cpp:4:注意是最靠近自己的颜色才能判定，那么假如我想对一个数做贡献，那么可以连接上一个一样的数，然后让中间的数全都为一个颜色才行
answers/GD-S00907/color/color.cpp:5:可以证明，假若有多个一样的数，肯定不会用相隔的数去求,那么每一个相等的数就分成了一块一块，令这种颜色为蓝色，此时有两种不同的贡献
answers/GD-S00907/color/color.cpp:6:一种就是这两个数的贡献，另一种就是相邻的两个数
answers/GD-S00907/color/color.cpp:7:尝试dp,dp[x][0/1]表示构造到第x个点为红色/蓝色的最大权值,预处理出上一个数为be[x]还有中间相邻数的前缀和r[x]-l[be[x]],注意特判上一个数和自己相连的情况
answers/GD-S00907/color/color.cpp:10:特殊情况，100000111110，会有相交的可能
answers/GD-S00907/color/color.cpp:11:那么特判一下，be[x]+1与be[be[x]+1]相连，其实就是dp[x][0]=dp[be[x]+1][1]+相邻的值+a[i]
answers/GD-S00907/color/color.cpp:12:相邻的值给右边的值再做前缀和，然后如果l与这个值相撞，就要减去这个值
answers/GD-S00907/color/color.cpp:29: //还是记得清空
answers/GD-S01510/detect/detect.cpp:19:bool check(ll l, ll r) { // 查询[l, r]有没有报警器
answers/GD-S01510/detect/detect.cpp:20: ll x = lower_bound(p + 1, p + 1 + m, l) - p; // 第一个>=l的报警器
answers/GD-S01510/detect/detect.cpp:38: ld s = (V * V - v[i] * v[i]) / (2 * a[i]); // 路程>S后会超速
answers/GD-S01510/detect/detect.cpp:39: l = max( (ll)floor(d[i] + s + 1), d[i]), r = L; // (d + s, L], 加一向下取整
answers/GD-S01510/detect/detect.cpp:42: l = d[i], r = L; // [d, L] 内的都会超速
answers/GD-S01510/detect/detect.cpp:45: ld s = (V * V - v[i] * v[i]) / (2 * a[i]); // 路程在<=s时超速
answers/GD-S01510/detect/detect.cpp:56: ll x = lower_bound(p + 1, p + 1 + m, r + 1) - p - 1; // 第一个<=r+1的警报器的上一个
answers/GD-S01510/duel/duel.cpp:23: ll res = min(cnt1, cnt2); // 打败的人
answers/GD-S01510/duel/duel.cpp:26: cnt1 += cnt2; // 沦为最弱的人
answers/GD-S02106/detect/detect.cpp:9:int st[N];//记录超速的车的编号
answers/GD-S02678/detect/detect.cpp:4: int di,vi,ai;//距离最南端di的位置驶入,以vi的初速度和ai的加速度
answers/GD-S02678/detect/detect.cpp:14: int n, m, L, V;//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S02586/detect/detect.cpp:31: scanf("%d%d%d%d",&n,&m,&l,&V);//车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S02586/detect/detect.cpp:35: /*其中第i 辆车从主干道上距离最南端di 的
answers/GD-S02586/detect/detect.cpp:36: 位置驶入，以vi 的初速度和ai 的加速度做匀加速运动向北行驶*/
answers/GD-S02586/detect/detect.cpp:57: printf("%ld ",chao.size());//一个问OK !!!!!!!!!!!!!!!!!
answers/GD-S02586/color/color.cpp:13: //选1
answers/GD-S02586/color/color.cpp:15: //选2
answers/GD-S00700/detect/detect.cpp:26: if(a[i]<0&&v[i]>V)//加小于0
answers/GD-S00700/detect/detect.cpp:28: if(a[i]>0)//加大于0
answers/GD-S00700/detect/detect.cpp:30: if(a[i]==0&&v[i]>V)//一值超速
answers/GD-S00700/detect/detect.cpp:32: if(a[i]==0&&v[i]<V)//无超速 ok
answers/GD-S00700/detect/detect.cpp:41: if(a[i]<0&&v[i]>V&&d[i]<=q[j]&&q[j]<=s[i])//加小于0
answers/GD-S00700/detect/detect.cpp:47: if(a[i]>0&&s[i]<=q[j])//加大于0
answers/GD-S00700/detect/detect.cpp:52: if(a[i]==0&&v[i]>V&&s[i]<=q[j])//一值超速
answers/GD-S00700/detect/detect.cpp:91: if(a[i]==0&&v[i]>V)//一值超速
answers/GD-S00600/detect/detect.cpp:23:int d[maxn],vq[maxn],a[maxn],p[maxn],num[maxn*10];//num数组代表从第i个位置到第1个位置的测速点数
answers/GD-S00600/detect/detect.cpp:37: cnta=0,cntb=0,cntc=0;//cnta存贮超速的区间,cntb存贮超速的车数
answers/GD-S00600/detect/detect.cpp:65: double dzd=(v*v-vv*vv)*1.00/(2*aa);//超速时的位移大小
answers/GD-S00600/detect/detect.cpp:71: }//如果在超速区间内有测速器，那么gg
answers/GD-S00600/detect/detect.cpp:72: }//如果在主干道外超速，那么不会有任何问题，但如果在主干道内超速，那么(dzd+dd,l]就是超速区间
answers/GD-S00600/detect/detect.cpp:74: }else if(aa<0){//如果初速度小于等于规定速度就永远超过不了，就不需要管它
answers/GD-S00600/detect/detect.cpp:76: double dzd=(v*v-vv*vv)*1.00/(2*aa);//超速时的位移大小
answers/GD-S00600/detect/detect.cpp:79: if(num[int(dzd)+dd+le]-num[dd-1]>0){//在端点处超速无法被计算到
answers/GD-S00600/detect/detect.cpp:82: }//如果在超速区间内有测速器，那么gg
answers/GD-S00600/detect/detect.cpp:83: }//如果在主干道外超速，那么不会有任何问题，但如果在主干道内超速，那么[dd,dzd+dd)就是超速区间
answers/GD-S00600/duel/duel.cpp:29: //找到第一个攻击力大于自身防御力的怪兽
answers/GD-S00600/duel/duel.cpp:39: ans--;//怪兽破防，被踢出
answers/GD-S00600/duel/duel.cpp:40: flaga[j]=1;//怪兽已经打过，不能再打了
answers/GD-S00600/color/color.cpp:57:规定1为红色，0为蓝色
answers/GD-S00600/arena/arena.cpp:26:规定1为红色，0为蓝色
answers/GD-S01742/detect/detect.cpp:18://车辆初始位置 初始速度 加速度 测速仪位置
answers/GD-S02980/detect/detect.cpp:15: bool surpass;//0为未超速 , 1为超速
answers/GD-S02980/detect/detect.cpp:61: if(ai<0){//速度减为0或距离为L视作驶离
answers/GD-S02980/detect/detect.cpp:94: //此处需要循环找
answers/GD-S02980/detect/detect.cpp:96: //先找必须取的测速仪
answers/GD-S02980/detect/detect.cpp:107: if(pp.empty()) break;//即已经不存在必须选取的测速仪了
answers/GD-S02980/detect/detect.cpp:108: //把必须取的测速仪可测得超速车先pass,设置为不超速surpass=0
answers/GD-S02980/detect/detect.cpp:122: //对pm进行去掉已测元素
answers/GD-S03409/detect/detect.cpp:4: double d,v,a,ll=0,rr=0;//ll-rr会被测到超速的区间
answers/GD-S00354/detect/detect.cpp:40: if(car[i].a==0){//加速度=0
answers/GD-S00354/detect/detect.cpp:43: if(sdt==n+1)continue;//无法检测
answers/GD-S00354/detect/detect.cpp:48: else if(car[i].a<0){//加速度<0
answers/GD-S00354/detect/detect.cpp:51: if(sdt==n+1||cv(car[i].v,dt[sdt]-car[i].d,car[i].a)<=V)continue;//无法检测 /检测时未超速
answers/GD-S00354/detect/detect.cpp:57: else{//加速度>0
answers/GD-S00354/detect/detect.cpp:59: if(sdt==n+1)continue;//无法检测 /检测时未超速
answers/GD-S01725/detect/detect.cpp:38:int getans1(double s){//P中第一个大于S的
answers/GD-S01725/detect/detect.cpp:48:int getans2(double s){//P中第一个小于S的
answers/GD-S01995/detect/detect.cpp:8:bool j[100005]={0}; // 1代表不能关
answers/GD-S00454/detect/detect.cpp:19: int p;//位置
answers/GD-S00454/detect/detect.cpp:20: int v;//初速度
answers/GD-S00454/detect/detect.cpp:21: int a;//加速度
answers/GD-S00454/detect/detect.cpp:31:bool check(int i,int j){//true意思是判定超速,false是没判定超速
answers/GD-S00454/detect/detect.cpp:33: int dis = pos[j] - e[i].p;//两者距离
answers/GD-S00454/detect/detect.cpp:59: //找到距离这人最近的检查点
answers/GD-S00454/detect/detect.cpp:62: //判断这个检查点会不会判定这个人寄
answers/GD-S00454/detect/detect.cpp:77: //判断这个检查点会不会判定这个人寄
answers/GD-S01571/detect/detect.cpp:54://void suan(int v0,int vc,int lc,int p)//v0初速 , vc加速 ， lc 一段到另一段的距离 ， p是在第几个测速器时的属性
answers/GD-S00612/duel/duel.cpp:8:int a[100005] = {0};//a表示攻击力为i的有几个
answers/GD-S00612/color/color.cpp:9:int c[200005] = {0};//染红为1，染蓝为-1
answers/GD-S02761/detect/detect.cpp:5://无调试版
answers/GD-S02761/detect/detect.cpp:12:long long nn;//超速车辆数
answers/GD-S02761/detect/detect.cpp:15:long long cs(long long x,long long xx)//车编号 位置
answers/GD-S02761/detect/detect.cpp:31: //初始化()
answers/GD-S02761/detect/detect.cpp:40: sort(p+1,p+1+n);//排列测速仪
answers/GD-S02761/detect/detect.cpp:42: for(long long i=1;i<=n;i++)//寻找超速车辆
answers/GD-S02761/detect/detect.cpp:60: if ( cs(i,L) > V*V )//走到头超速
answers/GD-S02761/detect/detect.cpp:62: while(l<r)//找开始超速的点
answers/GD-S02761/detect/detect.cpp:84: if( v[i] > V )//一开始有超速
answers/GD-S02761/detect/detect.cpp:86: while(l<r)//找停止超速的点
answers/GD-S02761/detect/detect.cpp:111: if(nn==0)//无超速车
answers/GD-S01679/detect/detect.cpp:15:}//判断前面是否有测速器,有为1
answers/GD-S01679/detect/detect.cpp:26:}//判断变速中是否过测速器 ，有为1
answers/GD-S01679/detect/detect.cpp:47:int card[1000003],carv[1000003],cara[1000003];//存储车的数据
answers/GD-S01679/detect/detect.cpp:59: cin>>pf[i];//记录摄像头的位置
answers/GD-S03035/detect/detect.cpp:54: if (a[i].v <= limv && a[i].a <= 0) //绝不可能超速
answers/GD-S03035/detect/detect.cpp:66: r = upper_bound(b + 1 ,b + m + 1 ,r) - b; //找最右边的
answers/GD-S03035/detect/detect.cpp:86: //贪心
answers/GD-S01582/duel/duel.cpp:22: }//中间数
answers/GD-S01582/duel/duel.cpp:29: }//最小数
answers/GD-S01582/duel/duel.cpp:34: }//最大数有几个
answers/GD-S01582/duel/duel.cpp:39: }//中间数有几个
answers/GD-S01582/duel/duel.cpp:44: }//最小数有几个
answers/GD-S01582/duel/duel.cpp:51: cout<<n<<"\n";//比大小
answers/GD-S02468/detect/detect.cpp:44: //printf("超时:%d %d\n",nn[i].ca,nn[i].cb);
answers/GD-S02393/detect/detect.cpp:23: scanf("%d", &p[i]);//已经保证有序
answers/GD-S02393/detect/detect.cpp:34: x = lower_bound(p + 1, p + 1 + m, d[i] + max(0, x)) - p;//第一个测到超速
answers/GD-S02393/detect/detect.cpp:43: --x;//这里是最后可以测到超速的位置
answers/GD-S02393/detect/detect.cpp:44: x = upper_bound(p + 1, p + 1 + m, d[i] + x) - p - 1;//最后一个测到的摄像头
answers/GD-S02393/duel/duel.cpp:9: x = n - x;//转成要删掉几个
answers/GD-S02393/duel/duel.cpp:26: if(check(mid))//是否可以只留下 mid 个
answers/GD-S01339/detect/detect.cpp:16:int sumd[Y]; // 前缀和，到这个位置有多少个测速仪
answers/GD-S01339/detect/detect.cpp:18:int t[Y]; // 多少个车子的要求覆盖了这个位置？（差分）
answers/GD-S01339/detect/detect.cpp:21: // 小于 zi/mu 的最大整数
answers/GD-S01339/detect/detect.cpp:28: // 计算每个点被多少个要求覆盖，并求出覆盖最多的点
answers/GD-S01339/detect/detect.cpp:41: if (maxt == 0) return false; // 全都删完了
answers/GD-S01339/detect/detect.cpp:48: p[maxp] = -1; // 这个测速仪已经被选中了，后面不要重复选
answers/GD-S01339/detect/detect.cpp:66: else c[i].l = c[i].r = -1; // 压根就没超速过 没要求
answers/GD-S01339/detect/detect.cpp:76: else c[i].l = c[i].r = -1; // 压根就没超速过 没要求
answers/GD-S02599/duel/duel.cpp:11: std::sort(r+1,r+n+1);//排序 小到大
answers/GD-S02599/duel/duel.cpp:12: for(unsigned int i=1,min=r[1];i<=n;i++){//桶数组
answers/GD-S02503/detect/detect.cpp:120: 打不出的二分查找,Man!!!!!!What can I say!;
answers/GD-S02503/color/color.cpp:5:int a[Maxn]; //0表示值 1表示前一个数的下标 2表示后一个数的下标
answers/GD-S02503/color/color.cpp:6:bool b[Maxn];//0是蓝 1是红
answers/GD-S02503/color/color.cpp:7:int numm[Maxn2];//记录i的前一个下标
answers/GD-S02503/color/color.cpp:97:// a[i][1] = -1;//没有前一个
answers/GD-S00445/detect/detect.cpp:7: // 开始处 开始速度 加速度
answers/GD-S00445/detect/detect.cpp:9: //测速仪位置
answers/GD-S00445/detect/detect.cpp:31:// //标记哪个测速仪需要使用
answers/GD-S00445/detect/detect.cpp:41://// cout<<" 速度"<<vc<<endl;
answers/GD-S00445/detect/detect.cpp:42:// //vc计算车在测速仪时的速度
answers/GD-S00445/detect/detect.cpp:72:普通输入：
answers/GD-S00445/detect/detect.cpp:81:无加速输入：
answers/GD-S00445/duel/duel.cpp:17: //mmap[i][1]是个数，[2]是下一个 ,mmap[i][3]是还有攻击能力的怪兽的个数
answers/GD-S00445/duel/duel.cpp:34: //head是要被打死的小目怪兽的下标
answers/GD-S00445/duel/duel.cpp:35: //tail是较大怪兽的下标
answers/GD-S03136/detect/detect.cpp:15:int find(int l,int r,int id){//超速点
answers/GD-S02699/detect/detect.cpp:4:int t,n,m,l,p[N],mp[N],y[N],z[N],vis[3005][3005];//记录检测仪的位置
answers/GD-S02699/detect/detect.cpp:8: int d;//初始位置
answers/GD-S02699/detect/detect.cpp:9: double v2,v,a;//现在的速度 ，初始速度，加速度
answers/GD-S00589/detect/detect.cpp:44: if(a[i]<0&&v[i]>V) {//在t秒以内超速
answers/GD-S00589/detect/detect.cpp:77: if(fl==0) {//ai==0 和 ai>0 的线段结尾都在L
answers/GD-S00589/color/color.cpp:6:ll ans,dp[N][N],sum[N][N],mx[N];//第i个数前一个不同色为j
answers/GD-S03455/duel/duel.cpp:4:bool f[100005];//第i个怪还在不在
answers/GD-S03455/duel/duel.cpp:5:long long gs[100005];//攻击力为i胡怪物有多少个
answers/GD-S01839/detect/detect.cpp:3:算法:??
answers/GD-S01839/detect/detect.cpp:4:思路:
answers/GD-S01839/detect/detect.cpp:6:匀速直线运动/匀加速直线运动:如果一个超速了,那么所有检测器都会判定为超速,留一个就可以
answers/GD-S01839/detect/detect.cpp:7:匀减速直线运动:如果第一个拍到了就可以了,只留下第一个(最后一个?)
answers/GD-S01839/detect/detect.cpp:9:特殊性质 A：保证 ai = 0。
answers/GD-S01839/detect/detect.cpp:10:特殊性质 B：保证 ai > 0。
answers/GD-S01839/detect/detect.cpp:11:特殊性质 C：保证 ai < 0，且所有车都不在最北端驶离主干道。
answers/GD-S01839/detect/detect.cpp:14:多测不清空,爆零两行泪
answers/GD-S01839/detect/detect.cpp:15:long long? 512MB? 每个测试点时限 1.0 秒 2.0 秒 1.0 秒 1.0 秒
answers/GD-S01839/detect/detect.cpp:58: for(int i=1;i<=n;i++) //在最后一个测速仪判断是否超速
answers/GD-S01839/detect/detect.cpp:62: double v1=sqrt(a[i].v*a[i].v+2*a[i].a*deltas); //到最后一个测速仪的时候的速度
answers/GD-S01839/detect/detect.cpp:71: bool over[N]; //over[i]:第i个车为超速的车
answers/GD-S01839/detect/detect.cpp:88: //bs[i]=1表示第i个测速仪开
answers/GD-S01839/detect/detect.cpp:127: ans1=0,ans2=300948787; //多测不清空,爆零两行泪
answers/GD-S01839/duel/duel.cpp:3:算法:贪心
answers/GD-S01839/duel/duel.cpp:4:思路:
answers/GD-S01839/duel/duel.cpp:5:r<=2 ans就是2的个数
answers/GD-S01839/duel/duel.cpp:6:100pts队列维护
answers/GD-S01839/duel/duel.cpp:9:long long? 512MB? 每个测试点时限 1.0 秒 2.0 秒 1.0 秒 1.0 秒
answers/GD-S01839/duel/duel.cpp:28: if(cnt2>=cnt1) cout<<cnt2;//可以杀的完1的怪
answers/GD-S01839/duel/duel.cpp:35: //杀手、猎物
answers/GD-S01839/duel/duel.cpp:74:15:03 正解?把数排序,每个a都分一层,攻击力高的去打小的
answers/GD-S01839/color/color.cpp:3:算法:暴力
answers/GD-S01839/color/color.cpp:4:思路:
answers/GD-S01839/color/color.cpp:7:多测不清空,爆零两行泪
answers/GD-S01839/color/color.cpp:8:long long? 512MB? 每个测试点时限 1.0 秒 2.0 秒 1.0 秒 1.0 秒
answers/GD-S01839/arena/arena.cpp:3:算法:看CCF数据
answers/GD-S01839/arena/arena.cpp:4:思路:输出样例
answers/GD-S01839/arena/arena.cpp:7:多测不清空,爆零两行泪
answers/GD-S01839/arena/arena.cpp:8:long long? 512MB? 每个测试点时限 1.0 秒 2.0 秒 1.0 秒 1.0 秒
answers/GD-S01829/detect/detect.cpp:4:int d[10010],v[10010],a[10010],p[10010],p_num[10010]; //p_num指每个测速仪能测出超速的车数
answers/GD-S01829/detect/detect.cpp:31: if(v[i]<=V) //全程匀速不超速
answers/GD-S01829/detect/detect.cpp:35: else //全程匀速超速
answers/GD-S01829/detect/detect.cpp:55: if(v[i]>V) //全程加速超速
answers/GD-S01829/detect/detect.cpp:73: else if(v[i]==V) //开始一瞬间不超速
answers/GD-S01829/detect/detect.cpp:93: double dis=(V*V-v[i]*v[i])*1.0/(2*a[i]); //速度为变为V时已经行驶的距离
answers/GD-S01829/detect/detect.cpp:114: if(v[i]<=V) //不可能超速
answers/GD-S01829/detect/detect.cpp:120: double dis=(V*V-v[i]*v[i])*1.0/(2*a[i]); //速度为变为V时已经行驶的距离
answers/GD-S01829/arena/arena.cpp:11:我讨厌自己一个人……
answers/GD-S01829/arena/arena.cpp:15:可我的泪水冰冷刺骨
answers/GD-S01829/arena/arena.cpp:18:一笑了之！？……
answers/GD-S01829/arena/arena.cpp:22:冬天又要来了
answers/GD-S01829/arena/arena.cpp:23:你还会像以前那样牵我的手吗
answers/GD-S01829/arena/arena.cpp:26:抱歉
answers/GD-S01829/arena/arena.cpp:27:不能陪你去看雪了
answers/GD-S01829/arena/arena.cpp:28: --待我泣泪成花
answers/GD-S01829/arena/arena.cpp:32:是看太久屏幕了吗？……
answers/GD-S01829/arena/arena.cpp:35:我好想有个人陪我
answers/GD-S01829/arena/arena.cpp:36:我好想回到从前
answers/GD-S01829/arena/arena.cpp:37:我好想好想你
answers/GD-S02816/color/color.cpp:26:打表过样例，暴力出奇迹。 __int64
answers/GD-S00765/detect/detect.cpp:28: //cout<<"# 第"<<i<<"辆车在第"<<j<<"个测速仪速度为"<<vi;
answers/GD-S00765/detect/detect.cpp:32: //cout<<" 被判定为超速 js="<<js<<endl;
answers/GD-S00765/detect/detect.cpp:34: //cout<<" 速度正常"<<endl;
answers/GD-S00765/detect/detect.cpp:37: //cout<<"# 第"<<i<<"辆车在第"<<j<<"个测速仪速度为"<<v[i];
answers/GD-S00765/detect/detect.cpp:40: //cout<<" 被判定为超速 js="<<js<<endl;
answers/GD-S00765/detect/detect.cpp:42: //cout<<" 速度正常"<<endl;
answers/GD-S00765/color/color.cpp:2://废了废了
answers/GD-S02956/detect/detect.cpp:2:// 璞丹璞丹
answers/GD-S02757/detect/detect.cpp:10:{//注意龙龙
answers/GD-S00074/detect/detect.cpp:19: for(int i=0;i<=n+10;i++){//初始化
answers/GD-S00074/detect/detect.cpp:35: //计算超速区间
answers/GD-S00074/detect/detect.cpp:36: if(v0>V && a>=0){//从头超到尾
answers/GD-S00074/detect/detect.cpp:41:// if(v0>V && a<0){//从头开始减速
answers/GD-S00074/detect/detect.cpp:52: if(v0<V && a>0){//从没超速开始加速
answers/GD-S00074/detect/detect.cpp:60: //printffffffffff<<"本次区间："<<l[i]<<' '<<r[i]<<'\n';
answers/GD-S00074/detect/detect.cpp:64: //输入摄像头位置并预处理前缀和
answers/GD-S00074/duel/duel.cpp:18: if(r[i-1]==r[i]) l++;//同级长度就++
answers/GD-S00074/duel/duel.cpp:21: ans=max(ans,l);//高了就选取更大值
answers/GD-S00074/duel/duel.cpp:22: l=1;//l长度要初始化
answers/GD-S02352/detect/detect.cpp:1:// 思路：在数据量较小时：模拟每一辆车的速度，判断到每一个测速点后是否会超速，最后判断哪些测速器没有使用，关闭
answers/GD-S02352/detect/detect.cpp:2:// 在A性质下，我们只要特判每一辆车是否在测速区间以及是否超速
answers/GD-S02352/detect/detect.cpp:14:// 驶入位置 初始速度 加速度
answers/GD-S02352/detect/detect.cpp:21:// ↓ 初始点 初始速度 加速度
answers/GD-S02352/detect/detect.cpp:24: // 限速 初始速度 加速度
answers/GD-S02352/detect/detect.cpp:37: non = 0; // 不用关掉的探头
answers/GD-S02352/detect/detect.cpp:55: bool flag = 0; // 有的车可能超速了但是没有被发现
answers/GD-S02352/detect/detect.cpp:56: if (c[i].v > maxv && c[i].a >= 0) { // 特判一波，一直超速
answers/GD-S02352/detect/detect.cpp:64: detect_car++; // 这里特判，由于接下来不继续，直接加
answers/GD-S02352/detect/detect.cpp:68: if (c[i].v <= maxv && c[i].a <= 0) { // 特判一波，一直没超速
answers/GD-S02352/detect/detect.cpp:72: double atv = c[i].d + atmaxv(c[i].d, c[i].v, c[i].a); // 计算在什么时候速度到达限速
answers/GD-S02352/detect/detect.cpp:74: if (c[i].v > maxv) { // 当初始速度大于限速时
answers/GD-S02352/detect/detect.cpp:84: } else { // 当初始速度小于等于限速时
answers/GD-S02352/detect/detect.cpp:101: // 把记录数据最多的n个探头合起来，算剩下的
answers/GD-S03130/detect/detect.cpp:55: // printf(" %d速度%d ",j,vn);
answers/GD-S03130/detect/detect.cpp:61: // printf("找到%d",vn);
answers/GD-S02382/duel/duel.cpp:11://int start[1010],end[1010],v[1010];//取头不取尾
answers/GD-S02609/detect/detect.cpp:13:bool solve(int id) { // 某车是否超速
answers/GD-S02609/detect/detect.cpp:15: double dmax; // 车在什么位置驶离公路
answers/GD-S02609/duel/duel.cpp:13:// 枚举 超低效
answers/GD-S02609/duel/duel.cpp:30:// 栈 更低效
answers/GD-S01049/detect/detect.cpp:56: } //全
answers/GD-S01801/detect/detect.cpp:1://多测记得清空！！！！
answers/GD-S01801/detect/detect.cpp:13: //判断所有人在最右边的杆是否超速
answers/GD-S01801/detect/detect.cpp:52://诈骗你只为告诉你 我调破防了！！！！
answers/GD-S01801/detect/detect.cpp:53://哭哭
answers/GD-S01801/color/color.cpp:1://多测清空！！！
answers/GD-S01801/color/color.cpp:2://long long计算一下
answers/GD-S01801/color/color.cpp:7:int d[maxn][maxn];//全放成同种颜色的贡献
answers/GD-S00251/detect/detect.cpp:10: // 鍑虹幇浣嶇疆 鍒濋€熷害 鍔犻€熷害
answers/GD-S02329/detect/detect.cpp:1:#include<stdio.h>//这题对拍感觉很难写，过了样例遂不管之。
answers/GD-S02329/detect/detect.cpp:181: long long x=upper_bound(p2+1,p2+m+1,q2[i].r)-p2-1;//其实这个贪心我不会证明正确性，但是过了样例？
answers/GD-S02329/detect/detect.cpp:201:这首欧阳修的诗我忘记了标题，但是我很喜欢这首诗，于是在这里分享给大家。
answers/GD-S02329/detect/detect.cpp:202:去年月夜时，花市灯如昼。
answers/GD-S02329/detect/detect.cpp:203:月上柳梢头，人约黄昏后。
answers/GD-S02329/detect/detect.cpp:204:今年元夜时，月与灯依旧。
answers/GD-S02329/detect/detect.cpp:205:不见去年人，泪湿春衫袖。
answers/GD-S02329/duel/duel.cpp:27:对一些知名 luogu 用户感到真挚的膜拜。
answers/GD-S02329/duel/duel.cpp:28:榆木华（他有 luogu 账号！）
answers/GD-S01343/detect/detect.cpp:6://L主干道长度 V道路限速
answers/GD-S01343/detect/detect.cpp:7://d驶入位置 v初始速度 a加速度
answers/GD-S01343/color/color.cpp:4:int flag[200010];//0没有 1红色 2蓝色
answers/GD-S00607/detect/detect.cpp:32: ll st=a[i].st,v0=a[i].v0*a[i].v0,aa=a[i].aa;//v0,vt均开了平方
answers/GD-S02043/detect/detect.cpp:1://每辆车都会被一个连续区间内的测速仪检测到超速
answers/GD-S02043/detect/detect.cpp:2://问题简化为，选出若干个点，使得每一个区间内都有点
answers/GD-S02043/detect/detect.cpp:3://这里是 2024.10.26 16:25 的 wsl，我过了这道题的所有大样例，希望不要挂分
answers/GD-S02043/duel/duel.cpp:1://f_{i} 为只考虑攻击力 <=i 的怪兽时，最少剩下多少怪兽
answers/GD-S02043/color/color.cpp:1://其实就把数组拆成两个序列，最终的权值为所有 A_{i} 的和减去两个序列中每个 A_{i} 连续段的开头
answers/GD-S02043/color/color.cpp:2://设 f_{i,j} 为整个序列
answers/GD-S02043/color/color.cpp:3://这种套路我见过
answers/GD-S02043/color/color.cpp:4://这里是 2024.10.26 17:50 的 wsl，但是我还是不会做，寄
answers/GD-S02807/detect/detect.cpp:25: for(c=1;c<=m;c++)//大到小
answers/GD-S02084/color/color.cpp:28: // 放在红色
answers/GD-S02084/color/color.cpp:30: // 放在蓝色
answers/GD-S02084/arena/arena.cpp:12: int p[20], val[20], tot; // 编号之和和编码
answers/GD-S02282/color/color.cpp:4:bool b[200010];//0是蓝 1是红
answers/GD-S03426/arena/arena.cpp:1:// 为啥过不去大样例？？？？？？？？？
answers/GD-S03426/arena/arena.cpp:2:// 我的阿克呜呜呜
answers/GD-S03426/arena/arena.cpp:3:// 是不是得有一车阿克？？？
answers/GD-S03426/arena/arena.cpp:4:// 又要被吊打了 /ll
answers/GD-S02930/detect/detect.cpp:3:/*记得删调试*/
answers/GD-S02930/detect/detect.cpp:13:}sp[N];//第i辆车在哪段区间超速
answers/GD-S02930/detect/detect.cpp:15:1.挨个判断车有没有超速
answers/GD-S02930/detect/detect.cpp:16:2.如果有车只在一个站超速那么这个站绝对不能删除
answers/GD-S02930/detect/detect.cpp:17:3.ai>0,一超速后面都超速
answers/GD-S02930/detect/detect.cpp:18: ai=0,超速就一直超速，要不一直不超速
answers/GD-S02930/detect/detect.cpp:19: ai<0,倒着来,剩下一段到起点都超速
answers/GD-S02930/detect/detect.cpp:41: //位移到这里刚好瞬时速度为V
answers/GD-S02930/detect/detect.cpp:44: }//预处理每辆车超速区间
answers/GD-S02930/detect/detect.cpp:56: if(!f)ans++;//当前线段内出现了点,且还没算贡献
answers/GD-S02930/detect/detect.cpp:58: f=1;//被覆盖过
answers/GD-S02930/detect/detect.cpp:64: /*有一些线段，问哪些线段覆盖了给定的点，
answers/GD-S02930/detect/detect.cpp:65: 然后删去未覆盖点的线段，再删去尽可能
answers/GD-S02930/detect/detect.cpp:66: 多的点，使得剩下的每个线段都覆盖了点
answers/GD-S02930/detect/detect.cpp:68: 如果一个点对应的所有线段都对应了其它点，
answers/GD-S02930/detect/detect.cpp:69: 那么可以删掉这个点*/
answers/GD-S02930/detect/detect.cpp:74: //所有盖在这个点上的线段
answers/GD-S02930/detect/detect.cpp:78: //线段盖了一个点，此时这个点不能删除
answers/GD-S02930/detect/detect.cpp:85: //所有盖在这个点上的线段
answers/GD-S02930/color/color.cpp:3:/*记得删调试*/
answers/GD-S02177/color/color.cpp:26: score[j] = next[j] ? seq[j] + dp[j] - dp[next[j]]:0;//拿区间的得分
answers/GD-S01023/detect/detect.cpp:39:// cout<<"超速！"<<i<<endl;
answers/GD-S01023/detect/detect.cpp:62:// cout<<"超速！"<<j<<endl;
answers/GD-S00207/detect/detect.cpp:19: for(int j=0;j<n;j++){//正式开始,每个样例
answers/GD-S00207/detect/detect.cpp:21: for(int z=0;z<m;z++){//每个测速点的速度
answers/GD-S00522/detect/detect.cpp:5:int T,n,m,L,V,sum=0;//=n表示车辆数量,m为测速仪数量,L为主干道长度,V为道路限速;
answers/GD-S00522/detect/detect.cpp:16: cin>>d[i]>>v[i]>>a[i];//v[i]为起始位置,v[i]为初始速度,a[i]为加速度
answers/GD-S02992/color/color.cpp:31: //先红再蓝
answers/GD-S01736/detect/detect.cpp:24:void dfs(int step,int cnt,int sum){ // cnt 个超速，sum 个测速仪
answers/GD-S01736/detect/detect.cpp:44://int find1(int x){ // 第一个超速的地方
answers/GD-S01736/detect/detect.cpp:107:// a[i] > 0 前期不超速，后期超速
answers/GD-S01736/detect/detect.cpp:108:// a[i] = 0 如果第一下超速，后面全部超速。反之亦然
answers/GD-S01736/detect/detect.cpp:109:// a[i] < 0 前期超速，后期不超速
answers/GD-S01736/detect/detect.cpp:110:// 二分查找第一个超速点与最后一个超速点。差分统计答案，对于所有测速点，若差分值 < 1 说明有一辆车
answers/GD-S01736/color/color.cpp:50: // i 与 i - 1 异色。
answers/GD-S01736/color/color.cpp:53: // i 与 i - 1 同色。
answers/GD-S02822/detect/detect.cpp:1:/*祝我/大家RP++!!!*/
answers/GD-S02822/duel/duel.cpp:1:/*祝我/大家RP++!!!*/
answers/GD-S02822/color/color.cpp:1:/*祝我/大家RP++!!!*/
answers/GD-S02822/arena/arena.cpp:1:/*祝我/大家RP++!!!*/
answers/GD-S00094/color/color.cpp:6:ll bl,re;//1为蓝，2为红
answers/GD-S00653/duel/duel.cpp:1:#include<bits/stdc++.h>//解压密码：HF#24THMC
answers/GD-S00653/duel/duel.cpp:15: sort(a,a+n); //从小到大
answers/GD-S00653/color/color.cpp:57: while(cp[p].r<j&&p<cp.size()){//使cp[p].r>=j
answers/GD-S00333/detect/detect.cpp:12: /** 注意！！ **/
answers/GD-S00333/duel/duel.cpp:13: /** 注意！！ **/
answers/GD-S00333/color/color.cpp:45: /** 注意！！ **/
answers/GD-S00333/arena/arena.cpp:8: /** 注意！！ **/
answers/GD-S01161/detect/detect.cpp:12://我爱c++:)
answers/GD-S01161/color/color.cpp:12://我爱c++:)
answers/GD-S01161/arena/arena.cpp:12://我爱c++:)
answers/GD-S02315/detect/detect.cpp:22: //只做匀速的话，他如果超时肯定就是在第一个就噶的
answers/GD-S02315/detect/detect.cpp:23: //那么我们完全可以只留下最后一个
answers/GD-S02315/duel/duel.cpp:5:int cnt[N]; //是否发起过攻击，就算发起过攻击也有可能会死掉
answers/GD-S02315/duel/duel.cpp:28: // cout<<i<<"被"<<j<<"吃掉"<<'\n';
answers/GD-S02315/duel/duel.cpp:29: cnt[j]=1;//j位置不可以吃人
answers/GD-S02315/duel/duel.cpp:30: a[i]=-1;//i位置死了
answers/GD-S02315/color/color.cpp:12: if(mark[i]==mark[j]){//同色
answers/GD-S02405/detect/detect.cpp:7://车辆数量、测速仪数量、主干道长度和道路限速。
answers/GD-S02405/detect/detect.cpp:9://驶入驾驶道的位置，初速度和加速度。
answers/GD-S02405/detect/detect.cpp:11://测速仪的位置。
answers/GD-S02405/detect/detect.cpp:13://是否超速？
answers/GD-S02405/detect/detect.cpp:15://这个测速器所测到超速的车的编号
answers/GD-S00951/duel/duel.cpp:6:bool tui[N]={false} , fa[N]={false};//均视为未发动攻击
answers/GD-S00951/duel/duel.cpp:9: tui[b]=true;//弱者退出游戏
answers/GD-S00951/duel/duel.cpp:11: fa[a]=true;//强者已经发动了攻击
answers/GD-S01943/duel/duel.cpp:38: // 攻击者变成used，原有used被打掉，不变
answers/GD-S01943/color/color.cpp:26: ll f[N1][N1]; // 结尾为j， 上个转移点不右于i
answers/GD-S01943/color/color.cpp:42: // 枚举最靠近的同色j, j~i为pure
answers/GD-S01665/detect/detect.cpp:19: for(int v=1;v<=m;v++){ //v是监控的距离
answers/GD-S01665/detect/detect.cpp:22: if(z<b[v][t] && z>b[v-1][t] && a[3][j][t]<0){ //a[2][j][t],a初速度,a[3][j][t],a加速度
answers/GD-S01665/detect/detect.cpp:24: //监控没测到
answers/GD-S00501/detect/detect.cpp:42: //计算超速车辆的位置区间
answers/GD-S00501/detect/detect.cpp:72: //完全没有超速车辆 ，直接跳过
answers/GD-S00501/detect/detect.cpp:124: //减去重复贡献
answers/GD-S00501/detect/detect.cpp:139: //二分找答案
answers/GD-S01146/detect/detect.cpp:5:int T,n,m,L,V,ans1;//分别表示数据个数、车辆数量、测速仪数量、主干道长度和道路限速。
answers/GD-S01146/detect/detect.cpp:13:} q[N];//超速边界
answers/GD-S00837/duel/duel.cpp:15: //cout<<"此时b[j]为"<<b[j]<<" "<<j;
answers/GD-S00837/duel/duel.cpp:18: //cout<<"此时b[j]为"<<b[j]<<" "<<j;
answers/GD-S03077/duel/duel.cpp:16: for(int i = 1; i <= n; i++) cout<<"第"<<i<<"项血量为："<<a[i]<<endl<<"第"<<i<<"项攻击对象为："<<attacked[i]<<endl<<"第"<<i<<"项是否存活为："<<alive[i]<<endl;
answers/GD-S02469/detect/detect.cpp:121:v[i]<0错误原因
answers/GD-S02469/detect/detect.cpp:125:会出错，只需要2但是3
answers/GD-S02469/detect/detect.cpp:126:炸缸了
answers/GD-S02020/color/color.cpp:11:ll d[maxn],yu[maxn],sum[maxn]; //yu是预处理；
answers/GD-S02896/detect/detect.cpp:3:int a[100001];//i的加速度
answers/GD-S02896/detect/detect.cpp:4:int d[100001];//i的起始点
answers/GD-S02896/detect/detect.cpp:5:int v[100001];//i的启示速度
answers/GD-S02896/detect/detect.cpp:6:int p[100001];//测速仪i的位置
answers/GD-S02896/detect/detect.cpp:7:bool q[10001];//i车会被判超速
answers/GD-S02896/detect/detect.cpp:8:bool k[10001][10001];//i车会被j测速仪判超速
answers/GD-S02896/detect/detect.cpp:9:bool g[10001];// i车在目前是否会被判超速
answers/GD-S02896/duel/duel.cpp:4:int b[200001];//活着的
answers/GD-S02896/duel/duel.cpp:5:int c[200001];//能打的
answers/GD-S01402/detect/detect.cpp:5:int d[10010]/*路程*/,v[10010]/*速度*/,a[10010]/*加速度*/;
answers/GD-S00742/detect/detect.cpp:62: if (a>=0) //已经超速但不会减速
answers/GD-S00742/detect/detect.cpp:64: // [d,L]区间一直超速
answers/GD-S00742/detect/detect.cpp:74: int p2=t; //[d,p2]中一直超速
answers/GD-S00742/detect/detect.cpp:89: double t=(double)d+(double)(V*V-v*v)/(2.0*a); //[p2,L]一直超速
answers/GD-S00344/detect/detect.cpp:6:int r[MAXL];//r[i]表示i处北边最近的测速仪的编号
answers/GD-S00344/detect/detect.cpp:27: //两个区间存在重叠部分,则进行合并
answers/GD-S00344/detect/detect.cpp:34: //不存在,则另启一组
answers/GD-S00344/detect/detect.cpp:57: int s=p[j]-d[i];//行驶到p[j]处的距离
answers/GD-S00344/detect/detect.cpp:58: int vt2=2*a[i]*s+v[i]*v[i];//行驶到p[j]处的速度^2
answers/GD-S00344/detect/detect.cpp:59: if(vt2>V2){//在p[j]位置测得超速
answers/GD-S00344/detect/detect.cpp:64: }else if(a[i]>=0){//若后续不减速,则后续测速仪均显示超速
answers/GD-S00344/detect/detect.cpp:68: }else{//在p[j]位置测得不超速
answers/GD-S00344/detect/detect.cpp:69: if(a[i]<=0) break;//若后续不加速,则后续测速仪均显示不超速
answers/GD-S00599/detect/detect.cpp:1://废案
answers/GD-S01282/detect/detect.cpp:7:int n,m,ans1,T,L,V,p[100002],ans2;//L为道路长度,V为限速
answers/GD-S01282/detect/detect.cpp:9: int d,v,a;//初始位置,初始速度,加速度
answers/GD-S01282/detect/detect.cpp:15:vector<Seg>lstp;//每个c最远的一个记录仪
answers/GD-S01282/detect/detect.cpp:53: int s=p[m]-c[i].d,tv=c[i].v*c[i].v+2*c[i].a*s;//瞬时速度的计算
answers/GD-S01282/detect/detect.cpp:72://当一辆车的初速度为v0时做匀加速运动，则t时刻后它的速度:v1 =v0+a ×t它的位移（即行驶路程s=v0*t+0.5*a*t2
answers/GD-S01282/detect/detect.cpp:73://当一辆车的初速度为v0、做匀加速运动，则当它的位移（即行驶路程）为s 时，这辆车的瞬时速度为sqrt(v0*v0+2*a*s)
answers/GD-S01282/detect/detect.cpp:74://第一种情况可以直接O(N)做完，只需要判断正负然后用第一个或者最后一个即可
answers/GD-S01282/detect/detect.cpp:75://第二种情况假了，这场比赛废了
answers/GD-S02062/detect/detect.cpp:7:inline bool check(int j,int i)//第j个测速仪是否会觉得第i辆车超速了
answers/GD-S01793/detect/detect.cpp:15: bool flag=0;//到最后a>=0是否会有超速
answers/GD-S01793/arena/arena.cpp:9:vector<vector<int> > mwin,nwin,stdwin;//mwin[i] 第i位可能获胜的选手集合 nwin存储现在的结果
answers/GD-S01793/arena/arena.cpp:23: else if(i<=nowl&&rnum[i]>=r){//擂主赢
answers/GD-S01793/arena/arena.cpp:26: else if(i>nowl){//不知道
answers/GD-S00841/detect/detect.cpp:85: long double dx=ca[i].d*1.0+x; //恰好超速位置
answers/GD-S00841/detect/detect.cpp:96: long double dx=ca[i].d*1.0+x; //恰好不超速位置
answers/GD-S00841/detect/detect.cpp:121:直接判断超不超速
answers/GD-S00841/detect/detect.cpp:122:二分找第一个摄像头
answers/GD-S00841/detect/detect.cpp:123:给第一个摄像头标记
answers/GD-S00841/detect/detect.cpp:124:没被标记的去掉
answers/GD-S00841/detect/detect.cpp:126:全部性质
answers/GD-S00841/detect/detect.cpp:127:对于a=0 同上
answers/GD-S00841/detect/detect.cpp:128:对于a>0 判断超速时的位置
answers/GD-S00841/detect/detect.cpp:129:若在最右边的摄像头内
answers/GD-S00841/detect/detect.cpp:130:则超速且最后一个摄像头标记
answers/GD-S00841/detect/detect.cpp:132:对于a<0 判断恰好不超速的位置
answers/GD-S00841/detect/detect.cpp:133:判断中间的摄像头
answers/GD-S00841/detect/detect.cpp:134:有则超速标最后一个
answers/GD-S00841/duel/duel.cpp:37:让差值尽可能小的去杀
answers/GD-S02998/detect/detect.cpp:25:pair<int,int> rng(int d,int v,int a){//在什么区间超速（闭区间）
answers/GD-S02998/detect/detect.cpp:26: //为什么公式这么长？（疑惑）
answers/GD-S02998/color/color.cpp:21: //红色
answers/GD-S02998/color/color.cpp:25: //蓝色
answers/GD-S02464/duel/duel.cpp:18: int maxn=INT_MIN,minn=INT_MAX;//找数值的上限和下限，优化
answers/GD-S03211/detect/detect.cpp:79: if(v[i] > V && query(d[i]) > 0){ // 判断小于等于d[i]有无测速仪
answers/GD-S03211/detect/detect.cpp:86: int l = lower_bound(p , p+1+m , my_up(tmp))-p , r = query(d[i]) ; // 判断小于等于my_up(tmp)有无测速仪
answers/GD-S01542/detect/detect.cpp:20: if(a[i].a>0) a[i].s=a[i].d+(v*v-a[i].v*a[i].v)/2/a[i].a,a[i].t=l;// 算出该车超速时的下标路程
answers/GD-S01542/detect/detect.cpp:28: cin>>c[i];// 测速仪的坐标
answers/GD-S00247/detect/detect.cpp:7: //d位 v初 a加
answers/GD-S00247/detect/detect.cpp:10:void add(int num){//初始化
answers/GD-S00247/detect/detect.cpp:15:bool judge(int i,int j){//区间是否检测
answers/GD-S00247/detect/detect.cpp:18:int out(int vv,int ad){//驶离位置
answers/GD-S00247/detect/detect.cpp:22:int solve(int v,int ad,int s){//路程求速度
answers/GD-S00247/detect/detect.cpp:41: int r=out(a[i].v,a[i].a)+a[i].d;//驶离位置
answers/GD-S00247/detect/detect.cpp:42: bool f=judge(a[i].d,r);//超速段是否检测
answers/GD-S01390/detect/detect.cpp:29: //都是匀速运动
answers/GD-S01390/detect/detect.cpp:45: //都是加速度运动
answers/GD-S01390/detect/detect.cpp:66: // 都是减速运动
answers/GD-S02005/detect/detect.cpp:10:car num[1000]={};//存储车
answers/GD-S02005/detect/detect.cpp:13:vector<int>shengyu;//剩余的没有被检测的车
answers/GD-S02005/detect/detect.cpp:14:vector<int>chaosu[10000];//记录第i个车超速的相机
answers/GD-S02005/detect/detect.cpp:15:int zongshu[10000];//记录每个相机识别到的超速的个数
answers/GD-S02005/detect/detect.cpp:16:vector<int>shibie[10000];//记录每个相机识别到的超速的车的编号
answers/GD-S02005/detect/detect.cpp:18:int camera[1000];//摄像机的位置
answers/GD-S02005/detect/detect.cpp:45: int sum1=0;//全部开启时超速的数量
answers/GD-S02005/detect/detect.cpp:48: for(int i=0;i<n;i++){//遍历每一个车
answers/GD-S02005/detect/detect.cpp:49: int d=num[i].d;//d起始位置
answers/GD-S02005/detect/detect.cpp:50: int v=num[i].v;//v速度
answers/GD-S02005/detect/detect.cpp:51: int a=num[i].a;//a加速度
answers/GD-S02005/detect/detect.cpp:53: if(a>0){//如果加速度大于0
answers/GD-S02005/detect/detect.cpp:55: float t=cha/a;//达到限速时所需的时间
answers/GD-S02005/detect/detect.cpp:56: float weizhi=v*t+(1/2)*a*t*t+d;//达到限速时的位置
answers/GD-S02005/detect/detect.cpp:64: for(int j=0;j<m;j++){//遍历每一个照相机的位置
answers/GD-S02005/detect/detect.cpp:66: //如果照相机的位置大于超速位置则可以识别到
answers/GD-S02005/detect/detect.cpp:68: //添加j号相机识别到的车
answers/GD-S02005/detect/detect.cpp:70: //添加可以记录到第i车的相机
answers/GD-S02005/detect/detect.cpp:72: //j号相机识别总数+1
answers/GD-S02005/detect/detect.cpp:73: if(bol==0){//如果车没有被识别过，标记为超速
answers/GD-S02005/detect/detect.cpp:81: int maxxx=0;//当前最多相机记录的数量
answers/GD-S02005/detect/detect.cpp:82: int linshi=0;//该相机的编号为linshi
answers/GD-S02005/detect/detect.cpp:94: //遍历这个相机可以识别到的车
answers/GD-S02005/detect/detect.cpp:95: int bh=shibie[linshi][xunhuan];//bh为车的编号
answers/GD-S02005/detect/detect.cpp:97: while(chaosu[bh][lin2]){//遍历识别到该车的相机
answers/GD-S02005/detect/detect.cpp:98: int lin3=chaosu[bh][lin2];//可以识别到bh车的相机
answers/GD-S02005/detect/detect.cpp:106: //识别到该车的相机的识别车的数量-1
answers/GD-S02005/duel/duel.cpp:15: int sum=0;//记录打败的个数
answers/GD-S01190/detect/detect.cpp:13:vector<int> isend[M]; // 有点蠢的vector...
answers/GD-S01190/detect/detect.cpp:24:int findBelow(int x){ // 在b[]中查找第最后一个小于等于x的
answers/GD-S01190/detect/detect.cpp:35:int findUpper(int x){ // 在b[]中查找第一个大于等于x的
answers/GD-S01190/detect/detect.cpp:63: if(a[i]) p = d[i] + (k*k-v[i]*v[i]) / (a[i]*2); // 下取整
answers/GD-S01190/detect/detect.cpp:125: // 多测记得清空！！！！！！！！！
answers/GD-S01913/detect/detect.cpp:73: for(int i = 1;i <= n;i++) // 排除没超速的区间
answers/GD-S01913/detect/detect.cpp:92: for(int i = 1;i <= m;i++) // 双指针 -> 每个摄像头的区间rg3
answers/GD-S01913/detect/detect.cpp:102: for(int i = 1;i <= m;i++) // 清除小区间 ,rg3->rg4
answers/GD-S01913/color/color.cpp:43:// 这种哈皮提也出的出来
answers/GD-S01913/arena/arena.cpp:24:int vis[20][N],to[20][N]; // 第 i 轮第 j 组的胜者是否仅有可能是明人
answers/GD-S01223/detect/detect.cpp:68: if(p[j]>=d[i]&&p[j]<=xx&&z[j]==false) cnt++,z[j]=true;//printf("第%d辆车以%d的初速度和%d的加速被位于%d的检速器发现违规 超速区间起始为",i,v[i],a[i],p[j]),cout<<d[i]<<"终点为"<<xx<<endl;
answers/GD-S01389/duel/duel.cpp:12: b[i]=true; //输入ri，初始化状态b为未退出游戏,a为未攻击
answers/GD-S01389/duel/duel.cpp:18: for(int j=i+1;j<=n;j++){ //找到第一只未攻击且攻击力比i大的怪兽
answers/GD-S01389/duel/duel.cpp:20: b[i]=false; //i死亡，j不能攻击
answers/GD-S03067/detect/detect.cpp:6://a 哪里驶入
answers/GD-S03067/detect/detect.cpp:7://b 初速度
answers/GD-S03067/detect/detect.cpp:8://c 加速度
answers/GD-S03067/detect/detect.cpp:9://d 测速仪位置
answers/GD-S01460/duel/duel.cpp:3:int a[100005],anss; //cha表示排序后a数组的差分数组 , scha表示差分数组的前缀和
answers/GD-S01460/color/color.cpp:1://多组数据不清空
answers/GD-S02985/detect/detect.cpp:58: //妄图以数学思维解决信息学
answers/GD-S02985/detect/detect.cpp:165: //2^n大暴力，O(2^n)的子集枚举几乎可以解决所有问题（笑）
answers/GD-S02985/detect/detect.cpp:218: }//将车辆超速区间求出后转化为一系列点与区间的经典问题
answers/GD-S02985/detect/detect.cpp:219: //应该是正解，但没时间打了只剩15分钟，拼尽全力遗憾落败
answers/GD-S02985/detect/detect.cpp:220: //逆天题目偶遇逆天样例解释，不读题又不聪明的拼尽全力无法AC
answers/GD-S02985/duel/duel.cpp:33: //小小贪心直接拿下
answers/GD-S02985/color/color.cpp:31: //拼尽全力未能想出的dp题，还是不如子集枚举
answers/GD-S02985/arena/arena.cpp:9: //蒟蒻oier偶遇逆天打擂台题目，超长题面与限制晃晕眼球，拼尽全力无法战胜(bushi)
answers/GD-S03408/arena/arena.cpp:12:// 绛旀
answers/GD-S00070/duel/duel.cpp:21: int n; ///////////初始化
answers/GD-S00125/detect/detect.cpp:11: //部分分
answers/GD-S02055/duel/duel.cpp:12:鏄笉鏄彲浠ヨ鏈€灏忕殑鎬吔浜掔浉鏀诲嚮
answers/GD-S02055/duel/duel.cpp:13:娆″皬鐨勬€吔鏀诲嚮鏈€灏忕殑
answers/GD-S02055/duel/duel.cpp:15:杩欎笉鍏搁锛岄珮涓夐€夋墜绉掍簡
answers/GD-S02055/color/color.cpp:21:鏄笉鏄彲浠ヨ鏈€灏忕殑鎬吔浜掔浉鏀诲嚮
answers/GD-S02055/color/color.cpp:22:娆″皬鐨勬€吔鏀诲嚮鏈€灏忕殑
answers/GD-S02055/color/color.cpp:25:杩欎笉鍏搁锛岄珮涓夐€夋墜绉掍簡
answers/GD-S02055/color/color.cpp:26:璐績
answers/GD-S02055/color/color.cpp:47:闂杞寲涓猴細
answers/GD-S02055/color/color.cpp:52:鎬ц川 A 涓€鍫嗗乏鍖洪棿
answers/GD-S02055/color/color.cpp:55:鎬ц川 B 渚濇棫鏄竴鍫嗗乏鍖洪棿
answers/GD-S02055/color/color.cpp:61:鎬ц川 C
answers/GD-S02055/color/color.cpp:62:涓€鍫嗗乏鍙抽棴鍖洪棿
answers/GD-S02055/color/color.cpp:64:杩欎簺鍖洪棿鐨勫乏鍙崇鐐归兘鏄樉鐒跺彲姹傜殑
answers/GD-S02055/color/color.cpp:66:1.鏄剧劧锛屼笉琚寘鍚湪浠讳綍鍖洪棿閲岃竟鐨勬祴閫熺偣鐪佸幓
answers/GD-S02055/color/color.cpp:67:2.闂杞寲涓猴細
answers/GD-S02055/color/color.cpp:69:鐪嬭捣鏉ュ緢鍍忚椽蹇冨拰 DP
answers/GD-S02055/color/color.cpp:73:鍏堣€冭檻 O(nm) DP
answers/GD-S02055/color/color.cpp:76:鑰冭檻鍒犳帀涓€鍒楃殑褰卞搷
answers/GD-S02055/color/color.cpp:89:16:34 鏆傛椂绂诲紑
answers/GD-S02055/color/color.cpp:123:T4 搴旇涓嶆槸鍥捐
answers/GD-S02055/color/color.cpp:127:16:34 寮€濮嬫墦鏆村姏
answers/GD-S02055/color/color.cpp:129:1 ~ 4 鏄剧劧鏆村姏鍙仛
answers/GD-S02055/color/color.cpp:144:濂藉儚姣旇緝 adhoc
answers/GD-S02055/color/color.cpp:146:浣嗘毚鍔涙湁 12pts
answers/GD-S01441/detect/detect.cpp:1://18:19爆了，开摆
answers/GD-S00727/detect/detect.cpp:4:int T,d[maxn],v[maxn],a[maxn],p[maxn],used[maxn],sxt[maxn];//桶记录超速
answers/GD-S00727/detect/detect.cpp:40: //判断是否超速
answers/GD-S00727/detect/detect.cpp:46: used[i]=1;//1为超速
answers/GD-S02297/detect/detect.cpp:8: int st,en;//超速起点，超速终点
answers/GD-S02297/detect/detect.cpp:38: if(car[i].v>v&&car[i].a>=0){//全程超速
answers/GD-S02297/detect/detect.cpp:42: else if((car[i].a==0)||(car[i].a<0&&car[i].v<v)){//全程不超速
answers/GD-S02297/detect/detect.cpp:51: double w=cal1(v,car[i].v,car[i].a);//速度降到V时
answers/GD-S01466/detect/detect.cpp:7: long long l,r;//超速时被检测的p是第几个
answers/GD-S01466/arena/arena.cpp:11:想过再挣扎一下t3，但是大半年没碰c++了，实在是觉得自己最后半个小时没能力调出来
answers/GD-S01466/arena/arena.cpp:12:也快要AFO了，原先信息队里有10几人，陆陆续续也都因为文化课而退了，剩下一个人孤独地搞竞赛真的没意思
answers/GD-S01466/arena/arena.cpp:13:这也应该是我的最后一场比赛了吧，noip不想考了，感觉玩了三年竞赛，总得留下些什么，就写点东西吧
answers/GD-S01466/arena/arena.cpp:15:信竞这条路真的很有意思
answers/GD-S01466/arena/arena.cpp:16:第一次集训去住宿是因为它
answers/GD-S01466/arena/arena.cpp:17:当初还马马虎虎的，不是拖鞋没带就是毛巾没带，但是和朋友一起在机房里的欢声笑语真的很令人难忘
answers/GD-S01466/arena/arena.cpp:18:那个时候的教练真的教的不好，总是听完课各自跑去找博客自学，然后一起讨论，讨论声越来越大，就被训斥了哈哈哈哈
answers/GD-S01466/arena/arena.cpp:19:想起我们打的那些模拟赛，教练总是吓唬我们说考不好就筛人，模拟赛的名字也很有意思，可惜我写下这句话的时候，才发现我记不起来了
answers/GD-S01466/arena/arena.cpp:20:还有晚修教练不在，悄悄打游戏摸鱼，当时有台电脑忘记关网页了留了一整晚，第二天早上就被抓包
answers/GD-S01466/arena/arena.cpp:21:集训完回到宿舍也是彻夜长谈，聊着从前的遗憾，聊着未来的期待
answers/GD-S01466/arena/arena.cpp:22:都好怀念啊
answers/GD-S01466/arena/arena.cpp:24:第一次喜欢上一个人也是因为它
answers/GD-S01466/arena/arena.cpp:25:想起当初在机房见到你，你说我小小一只很可爱，我也很受宠若惊
answers/GD-S01466/arena/arena.cpp:26:你总喜欢摸我的头，很舒服我很喜欢
answers/GD-S01466/arena/arena.cpp:27:记得当时跟你表白了，你也紧紧张张地不给我正面答复
answers/GD-S01466/arena/arena.cpp:28:有天在机房坐在你旁边，你突然抓住我的手，我也一下子没反应过来缩了回去
answers/GD-S01466/arena/arena.cpp:29:你也很可爱
answers/GD-S01466/arena/arena.cpp:30:总是我被摸头，那次我跟你走到了后门没人的地方，我也勇敢了一次摸了一下
answers/GD-S01466/arena/arena.cpp:32:后来你去了化竞
answers/GD-S01466/arena/arena.cpp:33:不过真好，寒假集训的时间有重合，又可以见到你了
answers/GD-S01466/arena/arena.cpp:34:那时候我生日，还拉着大家在机房吃蛋糕，还有肯德基，真的超级开心
answers/GD-S01466/arena/arena.cpp:35:那晚你陪我回宿舍了
answers/GD-S01466/arena/arena.cpp:36:我们也第一次牵了手
answers/GD-S01466/arena/arena.cpp:37:冬天真的很冷
answers/GD-S01466/arena/arena.cpp:38:但是我们脸颊都热热的红红的
answers/GD-S01466/arena/arena.cpp:40:18:20了，只有十分钟了，虽然写点东西不算作弊，但是每次监考老师走过身后的时候总是要假装在写代码
answers/GD-S01466/arena/arena.cpp:41:说实话有点希望赛后能在帖子上看到我这篇，如果有人翻到了能给我置顶展示一下吗
answers/GD-S01466/arena/arena.cpp:42:只剩7分钟了
answers/GD-S01466/arena/arena.cpp:43:许个愿吧
answers/GD-S01466/arena/arena.cpp:44:愿我以后天天开心
answers/GD-S01466/arena/arena.cpp:45:愿所读到这篇文章的人也天天开心
answers/GD-S01466/arena/arena.cpp:46:愿大家前程似锦
answers/GD-S01466/arena/arena.cpp:48:------致短短3年的OI生涯
answers/GD-S02806/detect/detect.cpp:45: //>=开始 小于超速
answers/GD-S00779/detect/detect.cpp:13:bool cs(int v0,int a,int dis){//判断以这个速度行驶 dis 后会不会超速
answers/GD-S00779/detect/detect.cpp:16:pair<int,int>ned(int v0,int a){//返回从当前点开始行走路程的区间是多少时会超速
answers/GD-S00779/color/color.cpp:82:int l[MAXN],r[MAXN];//记录每种颜色在线段树中的区间
answers/GD-S00779/arena/arena.cpp:57: if(d[x][dep]==0){//t1 中的数作擂主
answers/GD-S01051/duel/duel.cpp:15: for(int i=1;i<=n-1;i++){//找到第一个区间
answers/GD-S01051/duel/duel.cpp:25: for(int i=q1;;i++){//从第二个区间开始搜索
answers/GD-S00237/detect/detect.cpp:1://思路：对每辆车处理出会超速的区间，记录在每个测速仪上，最后取并
answers/GD-S02211/duel/duel.cpp:6:int main() // 祈求100分！！ O.O
answers/GD-S02211/arena/arena.cpp:4:int main() // 祈求有人看到（doge）
answers/GD-S02211/arena/arena.cpp:9: cout<<"太难了，不会（悲）";
answers/GD-S01616/detect/detect.cpp:3:int n,m,l,xv; //车辆数量、测速仪数量、主干道长度和道路限速
answers/GD-S01616/detect/detect.cpp:4:int d[1001],v[1001],a[1001]; //位置 初速度 加速度
answers/GD-S01616/detect/detect.cpp:5:int p[1001]; //道路上所有测速仪的位置
answers/GD-S01689/duel/duel.cpp:25: sum++;//记录一共有多少种不同的数字
answers/GD-S01689/duel/duel.cpp:33: int front=cnt[b[1]];//记录前面还有多少个小的没有减去
answers/GD-S01689/arena/arena.cpp:49: if(b[r][cop-1]=='0'){//小的做擂主
answers/GD-S02564/detect/detect.cpp:15:typedef double real; // 瀹炴暟绫诲瀷
answers/GD-S02564/detect/detect.cpp:18:// v 鍒濆閫熷害; a 鍔犻€熷害; s 閫熷害; t 鏃堕棿; Vt 褰撳墠閫熷害; St 褰撳墠璺▼; Vi 鐬棿閫熷害; Si 鐬棿璺▼.
answers/GD-S02564/detect/detect.cpp:40: // di: 椹跺叆浣嶇疆; vi: 鍒濆閫熷害; ai: 鍔犻€熷害.
answers/GD-S02564/detect/detect.cpp:42: real Vmax; // 鏈€澶ч€熷害
answers/GD-S02564/detect/detect.cpp:43: int Smax; // 椹跺嚭浣嶇疆
answers/GD-S02564/detect/detect.cpp:53: Vmax = Vi(vi, ai, L - di); // 鏈€澶ч€熷害
answers/GD-S02564/detect/detect.cpp:75: // 杈撳叆鏈夊簭
answers/GD-S00913/arena/arena.cpp:9://段考成绩好差，现已破防，求看到的人给个安慰……
answers/GD-S01777/detect/detect.cpp:2:// 部分分战神
answers/GD-S01777/detect/detect.cpp:9: int d, v, a;// 起始位置，速度，加速度
answers/GD-S01777/arena/arena.cpp:18:// 盲猜一波字典树 01trie
answers/GD-S01777/arena/arena.cpp:19:// 注意到这题超级多的数字都和 2 次幂有关
answers/GD-S01777/arena/arena.cpp:20:// 加上我没怎么学 S 组
answers/GD-S01777/arena/arena.cpp:21:// 还是打暴力ba
answers/GD-S01777/arena/arena.cpp:24:// 开摆！
answers/GD-S01777/arena/arena.cpp:26:对于性质 B，我们发现，无论到哪，我们都没有发现
answers/GD-S02698/duel/duel.cpp:4:int n,a[100005],d,nestart=1;//d->死的个数
answers/GD-S02038/detect/detect.cpp:37: if(dd<=dis){//已减为0
answers/GD-S02038/detect/detect.cpp:48:long long Find1(node x){//匀加速/匀速 在哪个测速点最先检出超速
answers/GD-S02038/detect/detect.cpp:67:long long Find2(node x,long long pos){//匀减速中最后一个检出超速的点
answers/GD-S01253/detect/detect.cpp:11: ll ss;//第一个检测*到*超速的探测器
answers/GD-S01253/detect/detect.cpp:12: ll es;//最后一个检测*到*超速的探测器
answers/GD-S01253/detect/detect.cpp:23:inline ll find(ll x)//在p中找比x大的第一个数
answers/GD-S01253/detect/detect.cpp:141: }//麻了第二问不会
answers/GD-S02625/detect/detect.cpp:10: //不会啊啊啊啊啊啊啊啊啊
answers/GD-S02625/color/color.cpp:10: //不会啊啊啊啊啊啊啊啊啊 *2
answers/GD-S02625/arena/arena.cpp:10: //啥啊这 不会啊啊啊啊啊啊啊啊啊 *3
answers/GD-S02075/color/color.cpp:3:int T, n, a[200005], color[200005], ans, f[2005][2005][2];//0 = r, 1 = b, f[i][j][k] i为k,j为k^1
answers/GD-S02396/duel/duel.cpp:26://这比【】【】密码锁简单。
answers/GD-S00366/detect/detect.cpp:5:int T, n, m, L, V, d[N], v[N], a[N], p[N], b[N], c[N], ans1, ans2; // b[i] 超速的车的 id c[i] 第 i 个测速仪选/不选
answers/GD-S00366/detect/detect.cpp:6:vector <int> f[N]; // f[i] 第 i 个测速仪检测的车
answers/GD-S00366/detect/detect.cpp:7://bool check(int x) // 删 x 个测速仪能否判定超速
answers/GD-S00366/detect/detect.cpp:17:void dfs(int step, int sum) // sum 保留了多少个
answers/GD-S00366/detect/detect.cpp:117: cout << ans1 << " "; // 有多少超速
answers/GD-S00366/detect/detect.cpp:140:// int l = 0, r = m; // 最多删多少个测速仪
answers/GD-S00366/color/color.cpp:5:int T, n, a[N], f[N][N]; // f[i][j] i 前面有 j 个相同颜色的数的答案
answers/GD-S00774/color/color.cpp:6://fi,j 代表前 i 位，最后一位染成与 i 不同颜色的位置是 j 的最大得分。 fi,j = fj+1,j + valj+1,i。 fi+1,i = maxfi,j = max(fj+1,j + valj+1,i);
answers/GD-S00878/detect/detect.cpp:29: //开始模拟
answers/GD-S01944/detect/detect.cpp:5:与加速度有关的定义和公式如下：
answers/GD-S01944/detect/detect.cpp:6:匀加速运动 是指物体在运动过程中，加速度保持不变的运动，
answers/GD-S01944/detect/detect.cpp:7:即每单位时间内速度的变化量是恒定的。
answers/GD-S01944/detect/detect.cpp:9:当一辆车的初速度为 v0、加速度 a != 0，做匀加速运动，
answers/GD-S01944/detect/detect.cpp:10:则 t 时刻后它的速度v1 = v0 + a × t
answers/GD-S01944/detect/detect.cpp:11:它行驶路程s = v0 × t + 0.5 × a × t ×t
answers/GD-S01944/detect/detect.cpp:13: 当一辆车的初速度为 v0、加速度 a != 0，做匀加速运动，
answers/GD-S01944/detect/detect.cpp:14: 则当它的位移（即行驶路程）为 s 时，
answers/GD-S01944/detect/detect.cpp:15: 这辆车的瞬时速度为 √v0的平方 + 2 ×a x (v0 × t + 0.5 × a × t ×t)
answers/GD-S01944/detect/detect.cpp:17:当一辆车的初速度为 v0、加速度 a != 0，
answers/GD-S01944/detect/detect.cpp:18:在它行驶路程为(v1的平方-v2的平方)/2a时，这辆车的瞬时速度为 v1。
answers/GD-S01944/detect/detect.cpp:19:如果你使用浮点数进行计算，需要注意潜在的精度问题。
answers/GD-S01944/detect/detect.cpp:22:输入的第一行包含一个正整数 T，表示数据组数。
answers/GD-S01944/detect/detect.cpp:23:接下来包含 T 组数据，每组数据的格式如下：
answers/GD-S01944/detect/detect.cpp:24:第一行包含四个整数 n, m, L, V ，分别表示车辆数量、测速仪数量、主干道长度和
answers/GD-S01944/detect/detect.cpp:25:道路限速。
answers/GD-S01944/detect/detect.cpp:26:接下来 n 行：
answers/GD-S01944/detect/detect.cpp:27:第 i 行包含三个整数 di, vi, ai 描述一辆车。
answers/GD-S01944/detect/detect.cpp:29:最后一行包含 m 个整数 p1, p2, · · · , pm
answers/GD-S01944/detect/detect.cpp:30:描述道路上所有测速仪的位置。
answers/GD-S01944/color/color.cpp:23: int ber = 0;//最近红色
answers/GD-S01944/color/color.cpp:24: int beb = 0;//最近蓝色
answers/GD-S02523/detect/detect.cpp:23://f[i]表示前i个区间，最后一次选了l[i]的最小值
answers/GD-S02523/color/color.cpp:11:int t, n, a[MAXN], f[MAXN][MAXN];//上一个红色是i，上一个蓝色是j的最大值
answers/GD-S02523/color/color.cpp:28: //如果i涂红色：
answers/GD-S02523/color/color.cpp:29: for(int j = 0;j < i - 1;j ++)//i - 1涂红
answers/GD-S02523/color/color.cpp:31: for(int j = 0;j < i - 1;j ++)//i - 1涂蓝
answers/GD-S02523/color/color.cpp:33: //如果i涂蓝色：
answers/GD-S02523/color/color.cpp:34: for(int j = 0;j < i - 1;j ++)//i - 1涂红
answers/GD-S02523/color/color.cpp:36: for(int j = 0;j < i - 1;j ++)//i - 1涂蓝
answers/GD-S03441/arena/arena.cpp:23: /*此处省略 3KB 代码*/
answers/GD-S02081/duel/duel.cpp:7://先写暴力 优化等写完暴力再想
answers/GD-S02081/duel/duel.cpp:8://尽可能的消灭最长到
answers/GD-S02081/duel/duel.cpp:25: int sum=0;//剩余
answers/GD-S01778/detect/detect.cpp:25: f[++cnt] = 1; // 标记超速嫌疑
answers/GD-S01778/detect/detect.cpp:46: } else f[j] = 0; // 之后不会有超速风险
answers/GD-S01778/duel/duel.cpp:8:// q:单调队列存当前怪物
answers/GD-S01778/duel/duel.cpp:9:// s:栈维护队列
answers/GD-S01778/duel/duel.cpp:10:// q2:维护吃怪物队列
answers/GD-S01778/duel/duel.cpp:12:bool b[N]; // 表示该编号怪物是否攻击过
answers/GD-S01778/duel/duel.cpp:33: // 队列不为空
answers/GD-S01778/duel/duel.cpp:46: // 该编号怪物没吃
answers/GD-S01778/duel/duel.cpp:50: // 该编号较大且已经吃了怪物
answers/GD-S01778/duel/duel.cpp:51: // 贪心策略
answers/GD-S01778/color/color.cpp:20:bool c[N]; // 染色情况
answers/GD-S01778/color/color.cpp:23: // 两种颜色前驱
answers/GD-S01778/color/color.cpp:56: // 全排列染色
answers/GD-S01778/arena/arena.cpp:32:// n个人第r轮
answers/GD-S02997/detect/detect.cpp:9:int main(){//pre为被观测超速的点的数量,vt为瞬速
answers/GD-S02548/duel/duel.cpp:25:/*压缩包:HF#24THMC*/
answers/GD-S03231/detect/detect.cpp:13: //T 行驶时间
answers/GD-S03231/detect/detect.cpp:14: //end 结束位置
answers/GD-S01559/detect/detect.cpp:8:double ss(int x,int y,int t){//初速度 加速度 限速
answers/GD-S01559/detect/detect.cpp:11: return sum1;//sum1是位移距离
answers/GD-S01559/detect/detect.cpp:13:double v1(int s,int v,int a)//计算瞬时速度
answers/GD-S02813/duel/duel.cpp:41:// cout << "屠杀者是" << wei[i] << "------" << endl;
answers/GD-S02813/duel/duel.cpp:43:// cout << "被杀者是" << wei[j] << "-------" << endl;
answers/GD-S02813/duel/duel.cpp:45:// cout << "屠杀者的数量>=被杀者的数量" << endl;
answers/GD-S02813/duel/duel.cpp:49:// cout << "可攻击的屠杀者还剩" << kgj[wei[i]] << endl;
answers/GD-S02813/duel/duel.cpp:51:// cout << "屠杀者的数量<被杀者的数量" << endl;
answers/GD-S02731/duel/duel.cpp:4:int card[JX];//记录每个卡牌的值
answers/GD-S02731/duel/duel.cpp:5:bool zt[JX];//记录每个卡牌的状态,true代表被使用过
answers/GD-S02731/duel/duel.cpp:6:bool die[JX];//记录卡牌是否出局,true代表出局
answers/GD-S02731/duel/duel.cpp:14: sum=a;//记录到最后还剩多少个卡牌
answers/GD-S02731/duel/duel.cpp:16: //遍历每一张卡牌
answers/GD-S02731/duel/duel.cpp:17: if(die[i])continue;//死了就跳过，没死透的（挑战过的）还可以加把劲再死一次
answers/GD-S02731/duel/duel.cpp:18: c=upper_bound(card,card+a,i)-card;//查询数值
answers/GD-S02731/duel/duel.cpp:20: //有人并且可以互殴
answers/GD-S02731/duel/duel.cpp:27: //还有人吗?或者那个人已经打累了
answers/GD-S02731/duel/duel.cpp:29: if(card[c]>card[i]&&zt[c]==false)break;//保证新找的数字要比原来的数字要大并且不能被使用过
answers/GD-S02731/duel/duel.cpp:33: zt[i]=true;//独孤求败，打得过也要放水
answers/GD-S02731/duel/duel.cpp:37: //不然就是找到合适的了
answers/GD-S03303/detect/detect.cpp:4:int T,n,m,l,v,N[200000][3],M[200000],N1[200000][3];//N[i][0]=起始位置
answers/GD-S01008/duel/duel.cpp:4:int n,a[N],b[N],m,c[N],cn,ta=-1,tb=-1,ans,zc=1;//b存活，c可攻击
answers/GD-S03341/arena/arena.cpp:12:// Tnlogn 卡常。算了算了，希望 CCF 机子跑快一点求求求了/ll/ll。
answers/GD-S03341/arena/arena.cpp:84: //lowsiz[u] <= dep[u] 的和
answers/GD-S00809/detect/detect.cpp:23:int need(int v, int a){//初速度为v，加速度为a
answers/GD-S00809/detect/detect.cpp:49: if (cr[i].a >= 0){//x+ned是第一个超过V的整点
answers/GD-S00809/detect/detect.cpp:53: else if (cr[i].v > V){//x+ned是第一个小于等于V的整点
answers/GD-S00809/color/color.cpp:57: //初值
answers/GD-S02662/detect/detect.cpp:28: for(int i=1;i<=L;i++){//我居然会浅醉何我真的是泰聪明辣
answers/GD-S01511/detect/detect.cpp:102: while(!ri[pt].empty())//收点
answers/GD-S02516/detect/detect.cpp:35: if(v0[i]<=V) continue;//匀速运动初速度小于等于限速
answers/GD-S02516/detect/detect.cpp:36: else{//匀速运动初速度大于限速
answers/GD-S02516/detect/detect.cpp:37: for(int j=1;j<=m;j++){//哪个测速点首次发现
answers/GD-S02516/detect/detect.cpp:38: if(p[j]>=d[i]){//测速点在当前位置或之后
answers/GD-S02516/detect/detect.cpp:40: found[j]++;//当前测速点超速车辆++
answers/GD-S02516/detect/detect.cpp:41: break;//仅判断首次
answers/GD-S02516/detect/detect.cpp:46: else if(a[i]>0){//加速运动
answers/GD-S02516/detect/detect.cpp:47: if(v0[i]>V){//加速运动初速度大于限速
answers/GD-S02516/detect/detect.cpp:48: for(int j=1;j<=m;j++){//判断首次发现的测速点
answers/GD-S02516/detect/detect.cpp:49: if(p[j]>=d[i]){//测速点在当前点或后
answers/GD-S02516/detect/detect.cpp:51: found[j]++;//当前测速点超速车辆++
answers/GD-S02516/detect/detect.cpp:52: break;//仅判断首次
answers/GD-S02516/detect/detect.cpp:56: else{//加速运动初速度小于限速
answers/GD-S02516/detect/detect.cpp:57: for(int j=1;j<=m;j++){//判断每个测速点的速度
answers/GD-S02516/detect/detect.cpp:58: if(p[j]>=d[i]){//仅判断驶入后遇到的测速点
answers/GD-S02516/detect/detect.cpp:59: s=p[j]-d[i];//p[j]-d[i]=测速点到驶入点的距离
answers/GD-S02516/detect/detect.cpp:61: //sqrt(v0[i]*v0[i]+2.0f*a[i]*s)=位移为p[j]-d[i]时的瞬时速度
answers/GD-S02516/detect/detect.cpp:62: if(vt>V){//当瞬时速度>限速时
answers/GD-S02516/detect/detect.cpp:64: found[j]++;//当前测速点超速车辆++
answers/GD-S02516/detect/detect.cpp:65: break;//仅判断首次
answers/GD-S02516/detect/detect.cpp:71: else if(a[i]<0){//加速度小于0做匀减速运动
answers/GD-S02516/detect/detect.cpp:72: if(v0[i]<=V) continue;//如果匀减速的初速度小于限速则不可能超速
answers/GD-S02516/detect/detect.cpp:74: t=(V-v0[i])/a[i];//减速到限速所需要的时间 (V-v0[i])/a[i]
answers/GD-S02516/detect/detect.cpp:75: s=v0[i]*t+0.5f*a[i]*t*t;//减速至限速所需要的路程 v0[i]*t+0.5f*a[i]*t*t
answers/GD-S02516/detect/detect.cpp:76: for(int j=1;j<=m;j++){//寻找测速点
answers/GD-S02516/detect/detect.cpp:77: if(p[j]>=d[i]&&(p[j]-d[i])<s){//如果有测速点且测速点在减速途中
answers/GD-S02516/detect/detect.cpp:79: found[j]++;//当前测试点超速车辆++
answers/GD-S02516/detect/detect.cpp:80: break;//仅判断首次
answers/GD-S00899/detect/detect.cpp:13:ll dis[MAXN];//测速仪位置
answers/GD-S00899/detect/detect.cpp:15:bool vis[MAXN];//有一些区间会在solve1中检查出并不可以被覆盖,在这里记住
answers/GD-S00899/detect/detect.cpp:16:int tot = 0;//表示有效的区间
answers/GD-S00899/detect/detect.cpp:20: ll pos,v,a;//表示起始位置,初速度,加速度
answers/GD-S00899/detect/detect.cpp:21: ll l,r;//表示超速的区间(距离区间) 闭区间
answers/GD-S00899/detect/detect.cpp:24://先简化一下,所有l>r的全部舍弃
answers/GD-S00899/detect/detect.cpp:27:}lmt[MAXN];//限制条件,一共tot个
answers/GD-S00899/duel/duel.cpp:16: int pos = 1;//表示pos以及之后的怪物都还活着
answers/GD-S00899/arena/arena.cpp:12: //估计是最后一次CSP-S,随便留一句话... 算是打卡S祭了
answers/GD-S00899/arena/arena.cpp:13: //这一场打的挺欢乐,希望各位在这场S都玩的开心吧...
answers/GD-S00899/arena/arena.cpp:14: //望每个人终能追逐到自己的梦想!
answers/GD-S01576/detect/detect.cpp:5://T2:物理战神
answers/GD-S01576/duel/duel.cpp:4://T1:大水题
answers/GD-S00613/detect/detect.cpp:65: }//记录测到最多与其它已经决定开启的测速仪不同的超速车辆 的测速仪
answers/GD-S00613/detect/detect.cpp:71: }//将未被测出超速的车辆标记并计数
answers/GD-S00613/detect/detect.cpp:72: for(it1=cs.begin();it1!=cs.end();it1++)//遍历所有测速仪的超速测速数据
answers/GD-S00613/detect/detect.cpp:83: }//将可以关闭的测速仪关闭
answers/GD-S00613/color/color.cpp:63: dp2[i][j]=max(dp1[i+1][j-1]+a[i],max(dp2[i+1][j]+(a[i+1]==a[i]?a[i]:0),dp2[i][j-1]+(a[j]==a[j-1]?a[j]:0)));//染同色
answers/GD-S02536/detect/detect.cpp:47: //算出每辆车的超速区间
answers/GD-S02536/detect/detect.cpp:94: //全开时能抓多少 单调修改测速仪 区间查询是否有测速仪
answers/GD-S02536/detect/detect.cpp:114: //dp? f[i]表示抓全前i辆车所开的最少测速仪数量，好像是贪心
answers/GD-S02536/detect/detect.cpp:119: if(w[i].l<=last||vis[i]==0)continue;//左端点小于last，说明已经被抓了
answers/GD-S02536/detect/detect.cpp:120: //没有continue，说明没被抓 此时这辆车的右端点是最靠左的，如果不抓，就抓不到了
answers/GD-S02536/color/color.cpp:23:f[i][k]当k=0时，第i个数涂颜色1，反之涂颜色2
answers/GD-S02536/color/color.cpp:24:表示前i个数都涂色之后可获得的最大值
answers/GD-S02536/color/color.cpp:25:f[i][k]可以从f[j][k]转移（j<i）
answers/GD-S02536/color/color.cpp:30:但是last与i之间相同的数字该怎么求呢
answers/GD-S02536/color/color.cpp:33:单调队列优化？
answers/GD-S02536/color/color.cpp:34:值相同特殊处理
answers/GD-S02536/color/color.cpp:35:last[i]表示值与a[i]相同且f[last[i]][k]是其中的最大值
answers/GD-S02536/color/color.cpp:37:所以单调队列中存的就是a[i]!=a[j]的下标
answers/GD-S02536/color/color.cpp:38:维护的就是单调递减f[i][0]，队头的值最大
answers/GD-S02536/color/color.cpp:39:颜色不同应该也可以一起在一个队列中维护，不行不行
answers/GD-S02536/color/color.cpp:41:要分别用两个队列维护颜色1和颜色2
answers/GD-S01624/detect/detect.cpp:11:}//确定距现位置最近的测速仪 (编号)
answers/GD-S01624/detect/detect.cpp:39: w=S(d[j]);//最近测速仪编号
answers/GD-S01624/detect/detect.cpp:41: s=b[k]-d[j];//测速仪距车距离
answers/GD-S01624/detect/detect.cpp:42: V=sqrt(pow(v[j],2)+2*a[j]*s);//瞬时速度
answers/GD-S02288/detect/detect.cpp:4: int di;//离起点的距离
answers/GD-S02288/detect/detect.cpp:5: int vi;//初速度
answers/GD-S02288/detect/detect.cpp:6: int ai;//加速度
answers/GD-S00860/detect/detect.cpp:62: // 超速位移区间，双端均闭
answers/GD-S00860/detect/detect.cpp:103: // 计算速度
answers/GD-S00860/duel/duel.cpp:77:duel.cpp: In function ‘int main()’:
answers/GD-S00860/duel/duel.cpp:78:duel.cpp:64:12: warning: ignoring return value of ‘FILE* freopen(const char*, const char*, FILE*)’, declared with attribute warn_unused_result [-Wunused-result]
answers/GD-S00860/duel/duel.cpp:81:duel.cpp:65:12: warning: ignoring return value of ‘FILE* freopen(const char*, const char*, FILE*)’, declared with attribute warn_unused_result [-Wunused-result]
answers/GD-S00860/arena/arena.cpp:89: // 剩余比赛轮数
answers/GD-S00860/arena/arena.cpp:91: // 剩余人数
answers/GD-S00860/arena/arena.cpp:97: // 模拟比赛
answers/GD-S00860/arena/arena.cpp:102: // 模拟场次，mbr[r*2] 对 mbr[(r*2)+1]
answers/GD-S00860/arena/arena.cpp:107: // 后者为擂主
answers/GD-S00860/arena/arena.cpp:115: // 前者为擂主
answers/GD-S01644/color/color.cpp:63: bool _c = true,c1 = true;//临界点的颜色
answers/GD-S00508/detect/detect.cpp:15: int l, r; // 超速区间 [l, r]
answers/GD-S00508/detect/detect.cpp:16: bool b; // 没超速
answers/GD-S00508/detect/detect.cpp:17: bool c; // 超速且被检测到了
answers/GD-S00508/detect/detect.cpp:27: // !操作时所有位置右移1位!
answers/GD-S00508/detect/detect.cpp:56: long long v2 = c[i].v * c[i].v + 2 * c[i].a * (L + 1 - c[i].d); // 末速度^2
answers/GD-S00508/detect/detect.cpp:59: // 开始超速的位置. 这样计算被卡精度了.
answers/GD-S00508/detect/detect.cpp:76: // 这个也被卡了.
answers/GD-S00508/detect/detect.cpp:126: // !注意清空数组!
answers/GD-S00508/detect/detect.cpp:134:16:15 留以纪念：
answers/GD-S00508/detect/detect.cpp:139:正在比较文件 a.out 和 DETECT2.ANS
answers/GD-S00508/detect/detect.cpp:140:FC: 找不到差异
answers/GD-S00508/detect/detect.cpp:146:正在比较文件 a.out 和 DETECT2.ANS
answers/GD-S00508/detect/detect.cpp:147:FC: 找不到差异
answers/GD-S00508/detect/detect.cpp:153:正在比较文件 a.out 和 DETECT3.ANS
answers/GD-S00508/detect/detect.cpp:154:FC: 找不到差异
answers/GD-S00508/detect/detect.cpp:160:正在比较文件 a.out 和 DETECT4.ANS
answers/GD-S00508/detect/detect.cpp:185:正在比较文件 a.out 和 DETECT5.ANS
answers/GD-S00508/detect/detect.cpp:198:16:36 调试完成
answers/GD-S00508/color/color.cpp:11:// 这样的数据范围, 提交的时候一定会五彩缤纷的吧!
answers/GD-S00508/color/color.cpp:12:// 至少会有 绿-红-紫 三种颜色!
answers/GD-S00508/color/color.cpp:13:// 但愿回顾 OI 生涯的时候, 还能体会到这些色彩...
answers/GD-S00508/color/color.cpp:57: pos[i] = v[a[i]].size(); // 没有 CLion 标黄的强转
answers/GD-S00508/color/color.cpp:65: // 看起来像模像样的, 但其实一分不得.
answers/GD-S00508/color/color.cpp:102:// 身体不舒服啊...头好晕, 最后的两个小时基本啥也没干.
answers/GD-S00508/color/color.cpp:103:// 又离退役近了一步, 但始终没想好如何真正和 OI 告别.
answers/GD-S00693/detect/detect.cpp:1:// 多测清空
answers/GD-S01627/color/color.cpp:5:// Ⱦɫ
answers/GD-S00043/duel/duel.cpp:4:ll a[100005], c[100005], d[100005]; //b：可以发射 c：不可以发射
answers/GD-S00043/duel/duel.cpp:39: if(c[y])//如果有不能攻击的
answers/GD-S00043/duel/duel.cpp:41: tmp--;//死了
answers/GD-S00043/duel/duel.cpp:43: b[x]--;//不能攻击了
answers/GD-S00043/duel/duel.cpp:48: tmp--;//死了
answers/GD-S00043/duel/duel.cpp:49: b[x]--;//不能攻击了
answers/GD-S00043/duel/duel.cpp:50: c[x]++;//不能攻击了
answers/GD-S00043/duel/duel.cpp:51: b[y]--;//死了
answers/GD-S01982/arena/arena.cpp:86:估分 100+40+20+16=176，寄
answers/GD-S01982/arena/arena.cpp:88:洛谷 UID 678175，欢迎壶关
answers/GD-S01982/arena/arena.cpp:90:原神，启动！
answers/GD-S02494/color/color.cpp:27: a[1][num] = 1; //Ⱦɫ
answers/GD-S03394/detect/detect.cpp:52: if(a[i]>=0)s2[i]=L;//һֱDe javu
answers/GD-S01235/detect/detect.cpp:53: if (x.v * x.v + 2 * x.f * (p[mid] - x.p) > lim * lim) //超速
answers/GD-S01235/detect/detect.cpp:68: if (x.v * x.v + 2 * x.f * (p[mid] - x.p) > lim * lim) //超速
answers/GD-S02902/detect/detect.cpp:124: // 遍历q下所有元素（vector），若curr是元素的子集，则将元素更新为元素与curr的交集；
answers/GD-S02902/detect/detect.cpp:125: // 否则，将curr插入到q中去
answers/GD-S02902/duel/duel.cpp:53: int t = p[i];//当前怪物的r
answers/GD-S03033/detect/detect.cpp:1:// 第一问可以非常简单地，对于每辆车，如果加速度为正，
answers/GD-S03033/detect/detect.cpp:2:// 那么考虑最后一个测试仪，否则考虑第一个测试仪。
answers/GD-S03033/detect/detect.cpp:3:// 然后就可以得到答案，顺便把超速的车留下。
answers/GD-S03033/detect/detect.cpp:4:// 所以以下的“车”默认为超速的。
answers/GD-S03033/detect/detect.cpp:5:// 如果加速度为正，那么二分得出第一个检测到超速的地方，
answers/GD-S03033/detect/detect.cpp:6:// 否则得出最后一个检测到超速的地方。
answers/GD-S03033/detect/detect.cpp:7:// 此时有两种情况，第一种是所有加速度为正的车的
answers/GD-S03033/detect/detect.cpp:8:// 超速记录仪和所有加速度为负的超速记录仪有重合，
answers/GD-S03033/detect/detect.cpp:9:// 那么此时只需要保留一个。
answers/GD-S03033/detect/detect.cpp:10:// 否则需要保留两个，第一个和最后一个。
answers/GD-S03033/detect/detect.cpp:11:// 我是蒟蒻！
answers/GD-S03033/detect/detect.cpp:12:// 我很蒻！
answers/GD-S03033/detect/detect.cpp:14:// 另：为什么今年 €€￡ 这么喜欢多测。
answers/GD-S03033/detect/detect.cpp:16:// 下一题唱什么呢～
answers/GD-S03033/detect/detect.cpp:18:// 样例里有不好的东西（指 1 1 4）！
answers/GD-S03033/detect/detect.cpp:55:vector<car> positive, negetive; // negetive 应该没有拼错吧
answers/GD-S03033/detect/detect.cpp:56:vector<car> codeforces, codefancy; // 长颈鹿
answers/GD-S03033/detect/detect.cpp:59:// ？？？刚刚猜出来了虚拟机的用户密码是 123456，这么厉害？？！
answers/GD-S03033/detect/detect.cpp:60:// sudo -i 输个 123456 居然成功了？
answers/GD-S03033/detect/detect.cpp:61:// 可惜没网，不然就能 apt install 一个小游戏玩玩了
answers/GD-S03033/detect/detect.cpp:63:// 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇 找不同 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇
answers/GD-S03033/detect/detect.cpp:64:// 自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自在最早在
answers/GD-S03033/detect/detect.cpp:65:// 自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自白尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自自尊自责自在最早在
answers/GD-S03033/detect/detect.cpp:66:// ☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝ 找不同 ☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝
answers/GD-S03033/detect/detect.cpp:67:// ☝☝☝
answers/GD-S03033/detect/detect.cpp:75: // 在那十面埋伏四面楚歌的时候
answers/GD-S03033/detect/detect.cpp:76: // 刀光与剑影交错
answers/GD-S03033/detect/detect.cpp:78: // 生死无话
answers/GD-S03033/detect/detect.cpp:82: int mid = (l+r) >> 1; // 飞机鸥案！
answers/GD-S03033/detect/detect.cpp:95: // 在那十面埋伏四面楚歌的时候
answers/GD-S03033/detect/detect.cpp:96: // 刀光与剑影交错
answers/GD-S03033/detect/detect.cpp:98: // 生死无话
answers/GD-S03033/detect/detect.cpp:102: int mid = (l+r+1) >> 1; // 飞机鸥案！
answers/GD-S03033/detect/detect.cpp:121: car career; // 这个 'car' 是 'car'eer，下一个是什么呢
answers/GD-S03033/detect/detect.cpp:143: for(car carpet : positive) // 是 'car'pet！'car' 的小宠物！猜对了吗？
answers/GD-S03033/detect/detect.cpp:145: // 在这里要判定走到最后一个测速仪时会不会超速
answers/GD-S03033/detect/detect.cpp:146: // 速度为 sqrt(v^2+2ap)
answers/GD-S03033/detect/detect.cpp:147: // 超速速度为 V
answers/GD-S03033/detect/detect.cpp:151: // v^2+2ap 最多是 1000000 + 2000000000 = 2001000000 < INT_MAX...
answers/GD-S03033/detect/detect.cpp:152: // 不开 long long 也不会见祖宗
answers/GD-S03033/detect/detect.cpp:153: // 话说上午 CSP-J 我一个 long long 也没开，不会寄吧。。
answers/GD-S03033/detect/detect.cpp:154: // 说寄不说吧，文明你我他
answers/GD-S03033/detect/detect.cpp:155: // 注：T3 开的是 string，大家不会错吧。
answers/GD-S03033/detect/detect.cpp:157: // printf("[%d, %d, %d] 在 %d 速度是 sqrt(%d)！\n", carpet.d, carpet.v, carpet.a, p[m], vv);
answers/GD-S03033/detect/detect.cpp:160: // printf("[%d, %d, %d] 超速！\n", carpet.d, carpet.v, carpet.a);
answers/GD-S03033/detect/detect.cpp:169: // printf("[%d, %d, %d] 在 %d 速度是 sqrt(%d)！\n", carpet.d, carpet.v, carpet.a, p[carpet.q], vv);
answers/GD-S03033/detect/detect.cpp:172: // printf("[%d, %d, %d] 超速！\n", carpet.d, carpet.v, carpet.a);
answers/GD-S03033/detect/detect.cpp:179: printf("%d %d\n", VisualStudio.size(), m - qjfg(VisualStudio)); //
answers/GD-S03033/detect/detect.cpp:195:// ...还有从 di 驶入没考虑到
answers/GD-S03033/detect/detect.cpp:196:// 没事，不紧张
answers/GD-S03033/detect/detect.cpp:197:// 老师，我叫不紧张
answers/GD-S03033/detect/detect.cpp:198:// 那么每辆车是否超速还是可以方便地检验，只是时间复杂度变成了 O(log n) 而已。
answers/GD-S03033/detect/detect.cpp:199:// 那么每辆车都有一个超速的区间。
answers/GD-S03033/detect/detect.cpp:200:// 对于加速度为正的，区间还是一样延伸到末尾。
answers/GD-S03033/detect/detect.cpp:201:// 对于加速度为负的，就愕愕了。
answers/GD-S03033/detect/detect.cpp:202:// 但是加速度为负的还是一个区间
answers/GD-S03033/detect/detect.cpp:203:// 那么我们可以得知这个区间的开头和结尾
answers/GD-S03033/detect/detect.cpp:204:// 搞一搞差分
answers/GD-S03033/detect/detect.cpp:205:// 就可以得出什么呢
answers/GD-S03033/detect/detect.cpp:206:// qwq，我叫不紧张
answers/GD-S03033/detect/detect.cpp:209:// 长枪刺破云霞
answers/GD-S03033/detect/detect.cpp:210:// 放下一生牵挂
answers/GD-S03033/detect/detect.cpp:211:// 后面不会唱啦
answers/GD-S03033/detect/detect.cpp:213:// 一招破苍穹～
answers/GD-S03033/detect/detect.cpp:215:// 风卷残云烈马
answers/GD-S03033/detect/detect.cpp:217:// (换个频道吧)
answers/GD-S03033/detect/detect.cpp:219:// 我知道了，但
answers/GD-S03033/detect/detect.cpp:220:// 你出言不逊是
answers/GD-S03033/detect/detect.cpp:221:// ！！.......
answers/GD-S03033/detect/detect.cpp:223:// 洛谷将会臭名
answers/GD-S03033/detect/detect.cpp:224:// 昭著！！！！
answers/GD-S03033/detect/detect.cpp:226:// ...全天下的
answers/GD-S03033/detect/detect.cpp:227:// OIers 都会
answers/GD-S03033/detect/detect.cpp:228:// 知道，CCF
answers/GD-S03033/detect/detect.cpp:229:// 和特派员的
answers/GD-S03033/detect/detect.cpp:230:// 腐朽！！！
answers/GD-S03033/detect/detect.cpp:231:// CCF 将会
answers/GD-S03033/detect/detect.cpp:232:// 臭名昭著！
answers/GD-S03033/detect/detect.cpp:233:// ————江轩
answers/GD-S03033/detect/detect.cpp:238: ↖↑↗ ↘↓↙ ↖↑↗ ↘↓↙ ↖↑↗
answers/GD-S03033/detect/detect.cpp:239:O←O→O→O←O←O→O→O←O←O→O
answers/GD-S03033/detect/detect.cpp:240: ↙↓↘ ↗↑↖ ↙↓↘ ↗↑↖ ↙↓↘
answers/GD-S03033/detect/detect.cpp:241:O→O←O←O→O→O←O←O→O→O←O
answers/GD-S03033/detect/detect.cpp:242: ↖↑↗ ↘↓↙ ↖↑↗ ↘↓↙ ↖↑↗
answers/GD-S03033/detect/detect.cpp:243:O←O→O→O←O←O→O→O←O←O→O
answers/GD-S03033/detect/detect.cpp:244: ↙↓↘ ↗↑↖ ↙↓↘ ↗↑↖ ↙↓↘
answers/GD-S03033/detect/detect.cpp:245:O→O←O←O→O→O←O←O→O→O←O
answers/GD-S03033/detect/detect.cpp:246: ↖↑↗ ↘↓↙ ↖↑↗ ↘↓↙ ↖↑↗
answers/GD-S03033/detect/detect.cpp:247:O←O→O→O←O←O→O→O←O←O→O
answers/GD-S03033/detect/detect.cpp:248: ↙↓↘ ↗↑↖ ↙↓↘ ↗↑↖ ↙↓↘
answers/GD-S03033/detect/detect.cpp:249:我的 CSP-S 像洛谷专栏一样成功！
answers/GD-S03033/detect/detect.cpp:250:洛谷专栏像我的 CSP-S 一样成功！
answers/GD-S03033/detect/detect.cpp:251:《互惠互利》
answers/GD-S03033/duel/duel.cpp:1:// 有一个显然的贪心
answers/GD-S03033/duel/duel.cpp:2:// 对于每一个怪兽，都选择比它能力值高一点点的怪兽来打它
answers/GD-S03033/duel/duel.cpp:3:// 啊啊啊啊啊啊
answers/GD-S03033/duel/duel.cpp:4:// 别打我
answers/GD-S03033/duel/duel.cpp:6:// 然后，用一个桶记录
answers/GD-S03033/duel/duel.cpp:7:// 我要上迷惑行为大赏！
answers/GD-S03033/duel/duel.cpp:8:// 监考老师不会进 NOI Linux，我自己进去了！
answers/GD-S03033/duel/duel.cpp:9:// 监考老师不会用 NOI Linux 的中文输入法，我自己设置好了！
answers/GD-S03033/duel/duel.cpp:10:// 我是神犇！
answers/GD-S03033/duel/duel.cpp:11:// 我是蒟蒻！
answers/GD-S03033/duel/duel.cpp:13:// 我的准考证号是 GD-S03033！
answers/GD-S03033/duel/duel.cpp:43:// 复制第四个样例时的剪贴板：你干嘛——哈哈—哎——呦——喂————
answers/GD-S03033/color/color.cpp:1:// 草，只会暴力了。
answers/GD-S01163/detect/detect.cpp:21: int tot=0,mustc=0;//超速车总数 ,必要测速仪
answers/GD-S02015/detect/detect.cpp:58: if (up % down != 0 && (up > 0) != (down > 0)) div--; // 唉 c++
answers/GD-S02738/detect/detect.cpp:11:}f[10005];//״̬
answers/GD-S01622/detect/detect.cpp:7:int csy[100005]; //测速仪
answers/GD-S01622/duel/duel.cpp:5:int players[100005][5]; //players[i][1:战力;2：存活(0：退出，1：存活，2：存活但无战力)]
answers/GD-S01622/duel/duel.cpp:24: if(n>10&&n<=30){ //性质a
answers/GD-S01622/duel/duel.cpp:40: int cnt = 0; //1的个数
answers/GD-S01622/duel/duel.cpp:47: cnt = n - cnt; //2的个数-1的个数
answers/GD-S01370/color/color.cpp:6:#define N 2100 //想出正解记得改 N ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
answers/GD-S00745/duel/duel.cpp:14: }//Ͱ
answers/GD-S01631/detect/detect.cpp:9: 0<=p<=L 严格递增
answers/GD-S01631/detect/detect.cpp:12: 都开启时被判定为超速的车辆数量
answers/GD-S01631/detect/detect.cpp:13: 最多可以关闭的测速仪数量
answers/GD-S02622/detect/detect.cpp:8:int cnt,ans;//超速车辆个数
answers/GD-S01245/detect/detect.cpp:98:5 5 ‐2
answers/GD-S01245/detect/detect.cpp:99:6 4 ‐4
answers/GD-S00098/detect/detect.cpp:45: while(l<=r){//求出对于这辆车第一个测速仪的位置
answers/GD-S00098/detect/detect.cpp:63: while(l<=r){//求出对于这辆车第一个测速仪的位置
answers/GD-S00098/color/color.cpp:42: //f[i][j][k][l]表示前i个数中，与第i个数颜色不同的第一个是j，在j左边与i颜色相同的是k，且i的颜色是l的最大值。
answers/GD-S02945/detect/detect.cpp:67: p[k]==-1;//ɾ
answers/GD-S00569/color/color.cpp:22: if(c[now]==1) //1Ϊblue
answers/GD-S00569/color/color.cpp:31: else if(c[now]==2) //2Ϊred
answers/GD-S02586/color/color.cpp:13: //ѡ1
answers/GD-S02586/color/color.cpp:15: //ѡ2
answers/GD-S01839/detect/detect.cpp:4:˼·:
answers/GD-S01839/duel/duel.cpp:4:˼·:
answers/GD-S01839/color/color.cpp:4:˼·:
answers/GD-S02956/detect/detect.cpp:1:// update 16:05：家人们终于把赤石模拟切掉了呃呃呃
answers/GD-S02956/detect/detect.cpp:2:// 豪赤豪赤
answers/GD-S02956/detect/detect.cpp:3:// 幽蓝边界即将吞噬像素塔...
answers/GD-S01049/detect/detect.cpp:56: } //ȫ
answers/GD-S00251/detect/detect.cpp:10: // 出现位置 初速度 加速度
answers/GD-S01079/detect/detect.cpp:12://记得检查数组大小
answers/GD-S01252/detect/detect.cpp:1:// 我来冲大模拟了 冲出来这辈子有了
answers/GD-S01252/detect/detect.cpp:2:// 我**你** 写了 1.5h
answers/GD-S01252/color/color.cpp:21: ll f[maxm], fw; // 上一个结束是什么数字 我打算下次要选 1 / fw : 不管你什么颜色了
answers/GD-S01252/color/color.cpp:22: ll g[maxm], maxg; // 我下一次不打算选 1 了，所以缓存下来这次的数字加给下下次
answers/GD-S00653/color/color.cpp:57: while(cp[p].r<j&&p<cp.size()){//ʹcp[p].r>=j
answers/GD-S02315/color/color.cpp:12: if(mark[i]==mark[j]){//ͬɫ
answers/GD-S00463/arena/arena.cpp:14:} tr[M]; LL Ans,Res; // tr[p].gl2 表示p子树内，补充选手获胜的最小价值。
answers/GD-S03408/detect/detect.cpp:92: // 不能删
answers/GD-S03408/color/color.cpp:97: ll a0 = query(1, m + 1, 1, 2 * m + 2, 1); // k = 0 的最大值
answers/GD-S03408/color/color.cpp:98: ll a1 = query(m + 2, 2 * m + 2, 1, 2 * m + 2, 1); // k = 1 的最大值
answers/GD-S03408/arena/arena.cpp:12:// 答案
answers/GD-S02055/duel/duel.cpp:12:是不是可以让最小的怪兽互相攻击
answers/GD-S02055/duel/duel.cpp:13:次小的怪兽攻击最小的
answers/GD-S02055/duel/duel.cpp:15:这不典题，高三选手秒了
answers/GD-S02055/color/color.cpp:21:是不是可以让最小的怪兽互相攻击
answers/GD-S02055/color/color.cpp:22:次小的怪兽攻击最小的
answers/GD-S02055/color/color.cpp:25:这不典题，高三选手秒了
answers/GD-S02055/color/color.cpp:26:贪心
answers/GD-S02055/color/color.cpp:30:好像是 DP
answers/GD-S02055/color/color.cpp:31:好像 O(n^2) 有 60
answers/GD-S02055/color/color.cpp:33:首先做第一问
answers/GD-S02055/color/color.cpp:35:若一辆车 a > 0，则只需检测它是否在终点前最后一个测速仪处超速
answers/GD-S02055/color/color.cpp:36:若一辆车 a <= 0，则只需检测它是否在下一个测速点超速
answers/GD-S02055/color/color.cpp:38:15:25 过了第一问
answers/GD-S02055/color/color.cpp:39:md 前两个样例好弱
answers/GD-S02055/color/color.cpp:41:第二问
answers/GD-S02055/color/color.cpp:43:对于 i，若 a[i] >= 0，
answers/GD-S02055/color/color.cpp:44:且它会被判定为超速，则判定它超速的测速仪是左闭区间
answers/GD-S02055/color/color.cpp:45:若 a[i] < 0，则判断它超速的测速仪是左右闭区间
answers/GD-S02055/color/color.cpp:47:问题转化为：
answers/GD-S02055/color/color.cpp:48:给定 n 个非空集合，求最多删除多少个元素使得每个集合不为空
answers/GD-S02055/color/color.cpp:50:15:50 又修了一下第一问..
answers/GD-S02055/color/color.cpp:52:性质 A 一堆左区间
answers/GD-S02055/color/color.cpp:53:找到最大的左端点，然后后面的元素都可以删 +20pts
answers/GD-S02055/color/color.cpp:55:性质 B 依旧是一堆左区间
answers/GD-S02055/color/color.cpp:56:同 A +20pts
answers/GD-S02055/color/color.cpp:58:怎么求区间端点呢？
answers/GD-S02055/color/color.cpp:59:先求出在超速时的位置，再 lower_bound！
answers/GD-S02055/color/color.cpp:61:性质 C
answers/GD-S02055/color/color.cpp:62:一堆左右闭区间
answers/GD-S02055/color/color.cpp:64:这些区间的左右端点都是显然可求的
answers/GD-S02055/color/color.cpp:66:1.显然，不被包含在任何区间里边的测速点省去
answers/GD-S02055/color/color.cpp:67:2.问题转化为：
answers/GD-S02055/color/color.cpp:68:给定一个 n * m 01 矩阵，删掉最多的列使每行至少有一个 1
answers/GD-S02055/color/color.cpp:69:看起来很像贪心和 DP
answers/GD-S02055/color/color.cpp:70:但贪心上题考过了
answers/GD-S02055/color/color.cpp:71:所以应该 DP
answers/GD-S02055/color/color.cpp:73:先考虑 O(nm) DP
answers/GD-S02055/color/color.cpp:75:f[i][j] 表示删到第 i 列，
answers/GD-S02055/color/color.cpp:76:考虑删掉一列的影响
answers/GD-S02055/color/color.cpp:77:只对本列是 1 的 x 有影响
answers/GD-S02055/color/color.cpp:79:每一次有两种选择：删 i，不删 i
answers/GD-S02055/color/color.cpp:80:删 i 时，f 由前面的情况转移而来
answers/GD-S02055/color/color.cpp:81:此时要 check 是否可行
answers/GD-S02055/color/color.cpp:83:不删 i 时，f 直接由前面的情况转移而来（有意义吗？）
answers/GD-S02055/color/color.cpp:84:此时不如不转移，直接枚举前面的
answers/GD-S02055/color/color.cpp:86:贪心？DP？
answers/GD-S02055/color/color.cpp:87:到底是什么呢？
answers/GD-S02055/color/color.cpp:89:16:34 暂时离开
answers/GD-S02055/color/color.cpp:100:删 124 134
answers/GD-S02055/color/color.cpp:111:ans = 3，留下 2
answers/GD-S02055/color/color.cpp:113:保留 2 列
answers/GD-S02055/color/color.cpp:116:最晚 17:00 开始打暴力
answers/GD-S02055/color/color.cpp:119:!!! sample 1 以题目下发为准
answers/GD-S02055/color/color.cpp:121:染色？
answers/GD-S02055/color/color.cpp:123:T4 应该不是图论
answers/GD-S02055/color/color.cpp:125:T3 应该要上图 好像不用？
answers/GD-S02055/color/color.cpp:127:16:34 开始打暴力
answers/GD-S02055/color/color.cpp:129:1 ~ 4 显然暴力可做
answers/GD-S02055/color/color.cpp:132:好像是 DP ？
answers/GD-S02055/color/color.cpp:136:表示到 i,染 i 为 j 色，上一个 R 为 a[k]，上一个 B 为 a[l] 的最大得分
answers/GD-S02055/color/color.cpp:144:好像比较 adhoc
answers/GD-S02055/color/color.cpp:146:但暴力有 12pts
answers/GD-S02564/detect/detect.cpp:15:typedef double real; // 实数类型
answers/GD-S02564/detect/detect.cpp:16:struct Info { int So, Se; }; // 超速车辆信息: 超速时刻; 结束超速时刻
answers/GD-S02564/detect/detect.cpp:18:// v 初始速度; a 加速度; s 速度; t 时间; Vt 当前速度; St 当前路程; Vi 瞬间速度; Si 瞬间路程.
answers/GD-S02564/detect/detect.cpp:28:// n: 车辆数量; m: 测速仪数量; L: 主干道长度; V: 道路限速.
answers/GD-S02564/detect/detect.cpp:31:// 超速数量
answers/GD-S02564/detect/detect.cpp:33:Info oser[MAXN]; // 超速车辆信息
answers/GD-S02564/detect/detect.cpp:40: // di: 驶入位置; vi: 初始速度; ai: 加速度.
answers/GD-S02564/detect/detect.cpp:42: real Vmax; // 最大速度
answers/GD-S02564/detect/detect.cpp:43: int Smax; // 驶出位置
answers/GD-S02564/detect/detect.cpp:44: real Sover = Infinity; // 超速位置
answers/GD-S02564/detect/detect.cpp:48: if(ai == 0) { // 匀速
answers/GD-S02564/detect/detect.cpp:49: if(vi > V) // 超速
answers/GD-S02564/detect/detect.cpp:52: } else if(ai > 0) { // 加速
answers/GD-S02564/detect/detect.cpp:53: Vmax = Vi(vi, ai, L - di); // 最大速度
answers/GD-S02564/detect/detect.cpp:54: if(Vmax > V) // 超速
answers/GD-S02564/detect/detect.cpp:57: } else if(ai < 0) { // 减速
answers/GD-S02564/detect/detect.cpp:58: if(vi > V) // 超速
answers/GD-S02564/detect/detect.cpp:75: // 输入有序
answers/GD-S02564/color/color.cpp:31: // 不会。
answers/GD-S02564/color/color.cpp:37: /// O(2^n) 也不会。
answers/GD-S02075/color/color.cpp:3:int T, n, a[200005], color[200005], ans, f[2005][2005][2];//0 = r, 1 = b, f[i][j][k] iΪk,jΪk^1
answers/GD-S00613/color/color.cpp:63: dp2[i][j]=max(dp1[i+1][j-1]+a[i],max(dp2[i+1][j]+(a[i+1]==a[i]?a[i]:0),dp2[i][j-1]+(a[j]==a[j-1]?a[j]:0)));//Ⱦͬɫ
本文来自博客园，作者：caijianhong，转载请注明原文链接：https://www.cnblogs.com/caijianhong/p/18528230
