2019 CCPC-Wannafly Winter Camp Day2(Div2, onsite)
solve 4/11
Code:KK
Thinking :KK
用ans表示当前最优答案，maxx表示遍历到的最大数字，一开始ans肯定等于a[ 1 ]+a[ 2 ]，然后每次往后找，都把当前的a [ j ]拼到maxx后面，然后和答案比较，每次也更新maxx，时间复杂度o（n）
注意数据是1e19，会爆long long，用unsigned long long 就可以过。
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define CLR(a,b) memset(a,b,sizeof(a));
const int inf=0x3f3f3f3f;
using namespace std;
typedef unsigned long long ll;
const int maxn= ;
int T;
int n;
ll a[maxn],maxx,ans;
int d[maxn];
void cut(int i,ll val){
d[i]=;
while(val>)
{
val/=;
d[i]++;
}
if(d[i]==)d[i]=;
}
int main(){
cin>>T;
int cat=;
while(T--)
{
cin>>n;
for(int i=;i<=n;i++)
{
//scanf("%lld",&a[i]);
cin>>a[i];
cut(i,a[i]);
}
maxx=max(a[],a[]);
ans=a[];
int time=d[];
while(time--){
ans*=;
}
ans+=a[];
for(int j=;j<=n;j++)
{
ll temp=;
temp =maxx;
time=d[j];
while(time--)
{
temp*=;
}
temp+=a[j];
ans=max(ans,temp);
maxx=max(maxx,a[j]);
}
printf("Case #%d: ",cat++);
cout<<ans;
printf("\n");
}
}
Code ：zz
Thinking：zz
题意：给出一串数（>=3），要求删除两个数，使得剩下的数拼接起来后最大。
删除的两个必然是长度最短的，先找出最短的数的长度，然后从前往后遍历数组，遇到长度最短的数就开始判断，如果发现拿走这个数后，总体的字典序是增加的，就去掉，并break;否则不去掉。如果长度最短的数至少有两个，那再进行一次上一步操作。在上两次操作中，如果有一次的操作进行了但却没有删除数，那就删掉数组最后面的长度最短的数。如果长度最短的数只有一个，那么进行类似第一步操作删除长度次短的数，如果没有删除数，那就删除数组最靠后的长度次短的数。
//#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<math.h>
#include<cmath>
#include<time.h>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
#include<numeric>
#include<stack>
#include<bitset>
const int inf = 0x3f3f3f3f;
using namespace std;
typedef long long ll;
struct s
{
long long num;
int len;
bool flag;
}z[];
int c1[], cc[];
int main(void)
{
//ios::sync_with_stdio(false);
int T, n, i, N = , id, len, sum, id2, len2, cnt1, j, ss, k, cntcc;
long long tmp, tmp1, tmp2, z1, z2;
int zz, ttmp;
scanf("%d", &T);
while (T--)
{
scanf("%d", &n);
id = -;
sum = ;
id2 = -;
cnt1 = ;
for (i = ; i < n; i++)
{
scanf("%lld", &z[i].num);
z[i].len = ;
z[i].flag = true;
tmp = z[i].num;
cntcc = ;
while (tmp)
{
cc[cntcc++] = tmp % ;
tmp /= ;
z[i].len++;
}
for (j = z[i].len - ; j >= ; j--)
{
c1[cnt1++] = cc[j];
}
if (id == -)
{
id = i;
len = z[i].len;
sum = ;
}
else if (len > z[i].len)
{
len = z[i].len;
id = i;
sum = ;
}
else if (len == z[i].len)
{
sum++;
}
}
if (sum == )
{
for (i = ; i < n; i++)
{
if (len != z[i].len)
{
if (id2 == -)
{
id2 = i;
len2 = z[i].len;
}
else if (len2 > z[i].len)
{
id2 = i;
len2 = z[i].len;
}
}
}
}
ss = ;
z1 = ;
for (i = ; i < n - && ss > ; i++)
{
z1 += z[i].len;
if (z[i].len == len)
{
z2 = z1;
for (j = i + ; j < n; j++)
{
z2 += z[j].len;
if (z[j].flag)
{
break;
}
}
zz = ;
for (k = ;; k++)
{
if (z1 - z[i].len + k > cnt1 || z2 - z[j].len + k > cnt1)
{
break;
}
if (c1[z1 - z[i].len + k] > c1[z2 - z[j].len + k])
{
zz = ;
break;
}
if (c1[z1 - z[i].len + k] < c1[z2 - z[j].len + k])
{
zz = ;
break;
}
}
if (zz == )
{
z[i].flag = false;
ss--;
}
}
}
z1 = ;
for (i = ; i < n - && ss; i++)
{
z1 += z[i].len;
if (z[i].len == len && z[i].flag)
{
z2 = z1;
for (j = i + ; j < n; j++)
{
z2 += z[j].len;
if (z[j].flag)
{
break;
}
}
zz = ;
for (k = ;; k++)
{
if (z1 - z[i].len + k > cnt1 || z2 - z[j].len + k > cnt1)
{
break;
}
if (c1[z1 - z[i].len + k] > c1[z2 - z[j].len + k])
{
zz = ;
break;
}
if (c1[z1 - z[i].len + k] < c1[z2 - z[j].len + k])
{
zz = ;
break;
}
}
if (zz == )
{
z[i].flag = false;
ss--;
}
}
}
sum -= ( - ss);
for (i = n - ; i >= && sum > && ss; i--)
{
if (z[i].flag && z[i].len == len)
{
z[i].flag = false;
ss--;
sum--;
}
}
z1 = ;
for (i = ; i < n - && ss; i++)
{
z1 += z[i].len;
if (z[i].len == len2 && z[i].flag)
{
z2 = z1;
for (j = i + ; j < n; j++)
{
z2 += z[j].len;
if (z[j].flag)
{
break;
}
}
zz = ;
for (k = ;; k++)
{
if (z1 - z[i].len + k > cnt1 || z2 - z[j].len + k > cnt1)
{
break;
}
if (c1[z1 - z[i].len + k] > c1[z2 - z[j].len + k])
{
zz = ;
break;
}
if (c1[z1 - z[i].len + k] < c1[z2 - z[j].len + k])
{
zz = ;
break;
}
}
if (zz == )
{
z[i].flag = false;
ss--;
}
}
}
if (ss)
{
for (i = n - ; i >= ; i--)
{
if (z[i].flag && z[i].len == len2)
{
z[i].flag = false;
ss--;
}
if (ss == )
{
break;
}
}
}
printf("Case #%d: ", N++);
for (i = ; i < n; i++)
{
if (z[i].flag)
{
printf("%lld", z[i].num);
}
}
printf("\n");
}
return ;
}
Code：KK zz
Thinking：KK
板子题，记住求球交的板子真的只能处理两个球相交的情况，然后小学数学处理一下各种球关系就好了（然而比赛时脑子打结，小学数学卡了了一下）
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define CLR(a,b) memset(a,b,sizeof(a));
const int inf=0x3f3f3f3f;
using namespace std;
const double PI = acos(-1.0);
typedef unsigned long long ll;
const int maxn= ;
typedef struct point {
double x,y,z;
point() { }
point(double a, double b,double c) {
x = a;
y = b;
z = c;
}
point operator -(const point &b)const { //返回减去后的新点
return point(x - b.x, y - b.y,z-b.z);
}
point operator +(const point &b)const { //返回加上后的新点
return point(x + b.x, y + b.y,z+b.z);
}
//数乘计算
point operator *(const double &k)const { //返回相乘后的新点
return point(x * k, y * k,z*k);
}
point operator /(const double &k)const { //返回相除后的新点
return point(x / k, y / k,z/k);
}
double operator *(const point &b)const { //点乘
return x*b.x + y*b.y+z*b.z;
}
}point; double dist(point p1, point p2) { //返回平面上两点距离
return sqrt((p1 - p2)*(p1 - p2));
}
typedef struct sphere {//球
double r;
point centre;
}sphere;
sphere s,a[maxn];
void SphereInterVS(sphere a, sphere b,double &v,double &s) {
double d = dist(a.centre, b.centre);//球心距
double t = (d*d + a.r*a.r - b.r*b.r) / (2.0 * d);//
double h = sqrt((a.r*a.r) - (t*t)) * ;//h1=h2，球冠的高
double angle_a = * acos((a.r*a.r + d*d - b.r*b.r) / (2.0 * a.r*d)); //余弦公式计算r1对应圆心角，弧度
double angle_b = * acos((b.r*b.r + d*d - a.r*a.r) / (2.0 * b.r*d)); //余弦公式计算r2对应圆心角，弧度
double l1 = ((a.r*a.r - b.r*b.r) / d + d) / ;
double l2 = d - l1;
double x1 = a.r - l1, x2 = b.r - l2;//分别为两个球缺的高度
double v1 = PI*x1*x1*(a.r - x1 / );//相交部分r1圆所对应的球缺部分体积
double v2 = PI*x2*x2*(b.r - x2 / );//相交部分r2圆所对应的球缺部分体积
v = v1 + v2;//相交部分体积
double s1 = PI*a.r*x1; //r1对应球冠表面积
double s2 = PI*a.r*x2; //r2对应球冠表面积
s = * PI*(a.r*a.r + b.r*b.r) - s1 - s2;//剩余部分表面积
}
int T,n;
double x,y,z,r;
int cas=;
int main(){
cin>>T;
while(T--)
{
cin>>n;
for(int i=;i<=n;i++)
{
scanf("%lf%lf%lf%lf",&x,&y,&z,&a[i].r);
a[i].centre={x,y,z};
}
scanf("%lf%lf%lf%lf",&x,&y,&z,&r);
s.r=r;
s.centre={x,y,z};
double ans=,v=;
for(int i=;i<=n;i++)
{
double ss,dis=dist(s.centre,a[i].centre);
//double
if(dis>=s.r+a[i].r)continue;
if(dist(s.centre,a[i].centre) + min(s.r,a[i].r) <= max(s.r,a[i].r))
{
ans += 4.0 / 3.0 * PI * min(s.r,a[i].r) * min(s.r,a[i].r) * min(s.r,a[i].r);
continue;
}
SphereInterVS(s, a[i],v,ss);
ans+=v;
}
printf("Case #%d: %.14f\n",cas++,ans);
}
}
Code：pai爷 zz
Thinking ：pai爷
时间复杂度为O(C(12,3)*C(9,3)*C(6,3)/24*T)
先预处理出所有的分割情况总共有369600种，之后去重24种，暴力判断。（用set去重或者hash，map去重待补）
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;
int p[][],a[],w[],t,n,l,zc=;
int check(int a,int b,int c)
{
if(a+b>c&&a+c>b&&b+c>a) return ;
return ;
}
struct s
{
int c[];
bool operator < (const s &rhs) const
{
for(int i = ;i <= ;i++)
{
if(c[i] != rhs.c[i])
{
return c[i] < rhs.c[i];
}
}
return ;
}
}aa;
set<s>st;
set<s>::iterator it;
void solve()
{
int i,j,k,l;
st.clear();
// printf("zc %d\n",zc);
for(k = ;k <= zc;k++)
{
for(i = ;i > ;i -= )
{
for(j = ;j <= i-;j += )
{
if(p[k][j] > p[k][j + ])
{
int temp[];
for(l = ;l <= ;l++)
{
temp[l] = p[k][j + l - ];
}
for(l = ;l <= ;l++)
{
p[k][j + l - ] = p[k][j + + l - ];
}
for(l = ;l <= ;l++)
{
p[k][j + + l - ] = temp[l];
}
}
}
}
memcpy(aa.c,p[k],sizeof(p[k]));
st.insert(aa);
//printf("****\n");
//zzz++;
// printf(" size = %d\n",st.size());
}
//printf(" %d\n",zzz);
zc = ;
for(it = st.begin();it != st.end();it++)
{
zc++;
//printf("111********************************\n");
//(*it)->second;
memcpy(p[zc],(*it).c,sizeof((*it).c));
}
// printf("zc = %d\n",zc);
}
int main()
{ /*for(int zzzz = 1;zzzz <= 12;zzzz++)
{
aa.c[zzzz] = zzzz;
}
st.insert(aa);
//aa.c[1] = 2;
st.insert(aa);
printf("%d\n",st.size());*/ scanf("%d",&t);
for(int x1=;x1<=;x1++)
for(int x2=x1+;x2<=;x2++)
for(int x3=x2+;x3<=;x3++)
for(int x4=;x4<=;x4++)
for(int x5=x4+;x5<=;x5++)
for(int x6=x5+;x6<=;x6++)
for(int x7=;x7<=;x7++)
for(int x8=x7+;x8<=;x8++)
for(int x9=x8+;x9<=;x9++)
{
//printf("%d\n",x9);
for(int k=;k<=;k++) a[k]=;
l=;
p[++zc][++l]=x1;p[zc][++l]=x2;p[zc][++l]=x3;
a[x1]=;a[x2]=;a[x3]=;
int sum=;
for(int k=;k<=;k++)
if(a[k]==)
{
sum++;
if(sum==x4) p[zc][++l]=k,a[k]=;
if(sum==x5) p[zc][++l]=k,a[k]=;
if(sum==x6) p[zc][++l]=k,a[k]=;
}
sum=;
for(int k=;k<=;k++)
if(a[k]==)
{
sum++;
if(sum==x7) p[zc][++l]=k,a[k]=;
if(sum==x8) p[zc][++l]=k,a[k]=;
if(sum==x9) p[zc][++l]=k,a[k]=;
}
for(int k=;k<=;k++)
if(a[k]==) p[zc][++l]=k;
// for(int i=1;i<=12;i++) printf("%d ",p[zc][i]);
// printf("\n");
}
solve();
int cas=;
while(t--)
{
int ans=;
for(int i=;i<=;i++) scanf("%d",&a[i]);
for(int i=;i<=zc;i++)
{
int sum=check(a[p[i][]],a[p[i][]],a[p[i][]])
+check(a[p[i][]],a[p[i][]],a[p[i][]])
+check(a[p[i][]],a[p[i][]],a[p[i][]])
+check(a[p[i][]],a[p[i][]],a[p[i][]]);
if(sum>ans)
{
ans=sum;
for(int j=;j<=;j++) w[j]=p[i][j];
if(ans==) break;
} }
printf("Case #%d: %d\n",++cas,ans);
for(int i=;i<=;i++)
{
if(check(a[w[(i-)*+]],a[w[(i-)*+]],a[w[(i-)*+]]))printf("%d %d %d\n",a[w[(i-)*+]],a[w[(i-)*+]],a[w[(i-)*+]]);
}
}
}
赛后总结：
KK：比赛开局oj有点爆炸，oj好了之后读a题，基本是读完就想到了解法，但是没和队友说清楚，纠结了一段时间，然后数据范围被坑了一下，快速ac。队友此时接管电脑写B，我就在旁边看计算几何，等队友wa了我也差不多想好了计算几何怎么写，然后再判断球相交的地方脑残了一些，卡了一会，ac。后面先和zz交流B，提供了几种不能ac的想法，zzAC，又和pai爷交流K题关于如何去重的东西，一直没理解pai爷的需求是啥，所以没想到用set，后来帮zz看了一些set的一些bug，还有改正了冒泡排序的写法？今天打的主要还是有一点点交流问题吧，总体还行，其他题目都处于题目都看不懂的状态了。div2Rank3，吹一波队友，希望大家一起加油！for dream！
pai爷：今天的比赛状态还行吧，莽了一下，TLE了，之后想到了去重的方法，在队友的帮助下解决了这个问题，要多学STL知识。
zz：今天做的B题可以说是很自闭了，在想出思路后，觉得自己的想法没什么问题就开始写了，写完后测了几组数据，没什么问题就交了一发，果不其然，wa了，然后很快找出了一个bug，有交了一发，果不其然，有wa了。然后看了好久代码，想了好久，都觉得没什么问题，直到碰巧造出了一组样例，我的代码没跑过，然后就意识到了问题的严重性，有个地方出了问题，后来花了点时间，写了一半，kk叫我去写H题里的一个东西，写完以后H题A了，我有继续写B题，有些了大概十几分钟，B题A了。然后金老师让我写一个去重的东西，我大概过程想好了就开始写了，写完以后测了下数据，哦豁完蛋，写崩了，调了下后发现是重载的问题，后来发现冒泡写的有问题，弄了好久才过了这题。然后就一起和金老师数三角形，这题比南京的那个数三角形难了好多，时间也不够，就没写出来。这个故事告诉我们，写代码以前要想清楚，不能拍拍脑袋就开始写了，也要加强和队友的交流。
2019 CCPC-Wannafly Winter Camp Day2(Div2, onsite)的更多相关文章
- CCPC-Wannafly Winter Camp Day2 (Div2, onsite)
Class $A_i = a \cdot i \% n$ 有 $A_i = k \cdot gcd(a, n)$ 证明: $A_0 = 0, A_x = x \cdot a - y \cdot n$ ...
- 2020 CCPC Wannafly Winter Camp Day1 C. 染色图
2020 CCPC Wannafly Winter Camp Day1 C. 染色图 定义一张无向图 G=⟨V,E⟩ 是 k 可染色的当且仅当存在函数 f:V↦{1,2,⋯,k} 满足对于 G 中的任 ...
- 2019 CCPC-Wannafly Winter Camp Day1 (Div2, onsite)
solve:4/11 补题:6/11 A 机器人 补题:zz 这是一道分类讨论的题目,有一个规律就是如果必须要从第一个区到第二个区,那么最多转区两次(1到2一次,2到1一次),然后分类讨论即可,只要细 ...
- 2019 CCPC-Wannafly Winter Camp Day7(Div2, onsite)
solve 6/11 补题: A.迷宫 Code:zz Thinking:zz kk 把每个节点的深度都处理出来,同一深度的点的冲突度为 (x-1),x为同层次点数减一. 然后冲突度不断下传(冲突度为 ...
- 2019 CCPC-Wannafly Winter Camp Day3(Div2, onsite)
solve 4/11 补题:5/11 A 二十四点* Code:pai爷 zz Thinking :pai爷 打表找规律,1张牌 10个不可能的 2张牌有 43 种不可能的 3张牌 有74 种不可能 ...
- 2019 CCPC-Wannafly Winter Camp Day4(Div2, onsite)
slove 6/11 A.夺宝奇兵 Code:zz Thinking:zz 贪心即可.这条路线里,点n1和点n2肯定是相连的,接下来,点(n-1)1和点(n-1)2分别是和n1和点n2相连的,一共有两 ...
- 2019 CCPC-Wannafly Winter Camp Day5(Div2, onsite)
solve 5/11 补题:7/11 A Cactus Draw Code:zz Thinking :zz 题意:要在n*n的网格内画上一棵节点数为n树,使得没有边相交. 很好想的构造题,因为网格有n ...
- CCPC Wannafly Winter Camp Div2 部分题解
Day 1, Div 2, Prob. B - 吃豆豆 题目大意 wls有一个\(n\)行\(m\)列的棋盘,对于第\(i\)行第\(j\)列的格子,每过\(T[i][j]\)秒会在上面出现一个糖果, ...
- CCPC-Wannafly Winter Camp Day5 (Div2, onsite) Sorting(线段树)
题目链接 题意 对序列进行三种操作: 1.区间求和. 2.将区间小于等于$x$的数不改变相对顺序的前提下放到$x$左边,用同样规则将比$x$大的放到右边. 3.将区间大于$x$的数不改变相对顺序的前提 ...
随机推荐
- IntelliJ IDEA 安装
1.在终端输入sudo vim /private/etc/hosts 2.在打开的hosts文件中,在尾行添加 0.0.0.0 account.jetbrains.com 3.去网站http://id ...
- a Concise Sparse Matrix package
简明稀疏矩阵包 https://github.com/kulhanek/csparse https://github.com/kulhanek/csparse
- Django框架 之 信号
Django中提供了“信号调度”,用于在框架执行操作时解耦.通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者. Django内置信号 Model signals pre_init ...
- 对SOA架构思想的一些说明(转)
出处:http://kb.cnblogs.com/page/510698/ 从纵向到横向 传统业务系统的构建更多的是竖井式的纵向思想,这个主要是从单个业务系统孤立来看都是垂直应用.那么SOA架构的视角 ...
- 启动samba服务--ubuntu 14.04
1. 修改配置文件 /etc/samba/smb.conf文件末尾添加 [homes] comment = Home Directories browseable = yes read only = ...
- Digital image processing(数字图像处理)
In computer science, digital image processing is the use of computer algorithms to perform image pro ...
- 设计模式23：Visitor 访问者模式（行为型模式）
Visitor 访问者模式(行为型模式) 动机(Motivation)在软件构造过程中,由于需求的改变,某些类层次结构中常常需要增加新的行为(方法),如果直接在基类中做这样的修改,将会给子类带来繁重的 ...
- javascript高级程序设计读书笔记----事件
DOM0级事件处理程序 传统处理方式,即讲一个函数赋值给一个事件处理程序属性. DOM2级事件处理程序 addEventListener()和removeHandler()两个方法用于指定和删 ...
- C++-结构体，联合体，枚举，的区别
结构体: struct NUM { int number; }a; 结构体是声明只是一个模型,没有分配内存空间.当进行定义结构体变量后才分配内存空间 联合体: union data { int a ...
- 下了个蓝屏代码查看工具，就中病毒了。。。什么鬼病毒，竟然还是用的VBS
扫描所有盘下面的html文件,加入VBS脚本...真是奇葩,多少年前的病毒了... http://files.cnblogs.com/files/guangshan/lpdmcxq.rar 这个是病毒 ...