首先给出红榜哈
接下来看看各题做题情况
然后看看各题解法吧..
*代表题目难度
**
第一题,有点见龙在田的味道...
给出一个长串,问它的2^n个子串里面是不是有"dragon"这个单词...
显然不能生成子集..
可以先找到字符d,然后r....,看看最终能不能找完所有字符...
一遍扫过去就好,不必回退,复杂度O(n)...
Problem B Rectangular Cuboid Checking
***
勉强算计算几何题...
给出3d空间内8个点,问能否构成长方体的8个顶点....
因为无序,8个点一共8!种情况,暴力枚举就好...
暴力方式:
一种做法,dfs生成全排列
一种做法,stl的next_permutation函数...
可以考虑对称性,减掉一半左右...
但其实本题代码已经不是很好敲了,建议不考虑...
复杂度:O(8!*每次判断)
Problem C The Biggest Number
*****
欧拉回路...
给n个数,如果数a的最后一位数字与数b的第一位数字相同可以连接...
求连接到的
将每个数字当做一条边,端点是头尾两个数字,一共0-9十个顶点
判断每个点的入度出度,三种情况
1、都相同:从最后一个点开始dfs
2、有两个点不同(而且都是相差1):从出度>入度的那个点开始dfs
3、其他:构不成回路,输出-1
dfs需要注意:
贪心的从最大的数字开始走,这样保证结果最大
判断最终走过的节点是不是n个,这样保证图是连通的..
复杂度:O(n)
Problem D Cutting the Number
****
大数+dp
给出一个很长的字符串,切割成很多小串
要求后面的小串里面数字比前面的大
求切割能得到的所有小串最小和...
dp是很显然的,但是代码有点难敲
dp[i][j]表示到i,最后一个小串是j-i能得到的最大,那么
dp[i][j] = min{dp[j-1][k]+s[j~i]} k<j-1 && s[k~j-1]<=s[j~i]
不能java, 需要模拟大数的比较 和 大数加法....
状态n*n,转移n,复杂度:O(n*n*n)
Problem E Alec’s Game
**
很好玩的一个题目...
三种颜色:三基色,颜色叠加之后会发生变化
三种命令:喷、吸、查询
开始时,盘子内没有颜色..
然后执行n条命令,对每次查询输出当前盘子内颜色
直接模拟就好..
可以用3个位代表三种颜色
那么,喷颜色就等于把那个位变成1,反之变成0,
预先关联好各种颜色与数组下标...
代码很好敲...
Problem F Delete Comments
**
坑人题...
给出一段代码,消除//注释
怎么找都行,stl的find,或者直接找...
这题估计会n多pe的...
最后别输出回车....
Problem G The Second Shortest Path
*****
次短路
给双向图,求单源次短路...
与一般题目不同的是要求次短必须严格小于最短...
Djs改进...
将每个点拆成两个点,更新完第一个点得到最短路
更新完第二个点得到次短路
因为严格小于,注意更新方式...
复杂度,邻接阵:O(N*N)
邻接表:O(N*N), 实际比邻接阵优很多
堆优化+邻接表:O(MlgN)
Problem H Recite Vocabulary
**
日期处理
给出两个合法日期(两个端点也算),求出它们之间的天数
得到平均每天的单词数目..
注意闰年的判断即可..
Problem I Love In WenShanLake
*
水题
这个题目是后来换上去的,因为大一的小朋友有一半左右...
本次比赛中最简单的题,也是个有爱题,正如题...
给出两个用细管连通的长方体的底面积和水面高度
求打开开关之后的水面高度
求出总体积然后除以总的底面积即可...
证明,连通器原理,因为大气压相等什么的...
注意输出舍入到整数位,可以%.lf,也可以+0.5之后%d处理
可惜了我原来的一个计数的题目
二维平面n个点,得到2^n个子集,问有多少对子集关于其中某个点对称
先去掉重复点,然后hash+公式...
数据出了两个小时,里面有线状、米字、格子的点...
还特意打表塞了个AC在里面...
Problem J Survival Game
***
BFS
脑筋急转弯的感觉...
给个类似迷宫的东西,里面有一个KEY,n多人,n多门...
问逃离迷宫的最少时间
从KEY处BFS最短路就好...
BFS到第一个人,第一个门,它们之和-1就是答案..
ahzlsd@gmail.com
感谢学生会信息部的协助!
感谢腾讯俱乐部的支持!
最后给几个代码(只有没人出的题目代码)
B:rectangular cubiod checking
#include "header.h"
const int pat[3][2][4]={
{{0,1,2,3},{4,5,6,7}},
{{1,5,6,2},{0,4,7,3}},
{{0,1,5,4},{3,2,6,7}}
};
struct node{
int x, y, z;
node(int _x, int _y, int _z):x(_x),y(_y),z(_z){}
bool operator == (const node & tmp) const
{
return (x==tmp.x && y==tmp.y && z==tmp.z);
}
};
vector<int> ind;
vector<node> dat;
// vector parallel
inline int pralCheck(int i, int k)
{
return ( (dat[ind[pat[i][0][k]]].x-dat[ind[pat[i][0][0]]].x)==(dat[ind[pat[i][1][k]]].x-dat[ind[pat[i][1][0]]].x) &&
(dat[ind[pat[i][0][k]]].y-dat[ind[pat[i][0][0]]].y)==(dat[ind[pat[i][1][k]]].y-dat[ind[pat[i][1][0]]].y) &&
(dat[ind[pat[i][0][k]]].z-dat[ind[pat[i][0][0]]].z)==(dat[ind[pat[i][1][k]]].z-dat[ind[pat[i][1][0]]].z));
}
// face parallel
inline int faceCheck(int i)
{
return ( pralCheck(i, 1) && pralCheck(i, 2) && pralCheck(i, 3) );
}
// calc distance
inline int disCalc(int i, int j, int k)
{
return ( (dat[ind[pat[i][j][k+2]]].x-dat[ind[pat[i][j][k]]].x)*(dat[ind[pat[i][j][k+2]]].x-dat[ind[pat[i][j][k]]].x)+
(dat[ind[pat[i][j][k+2]]].y-dat[ind[pat[i][j][k]]].y)*(dat[ind[pat[i][j][k+2]]].y-dat[ind[pat[i][j][k]]].y)+
(dat[ind[pat[i][j][k+2]]].z-dat[ind[pat[i][j][k]]].z)*(dat[ind[pat[i][j][k+2]]].z-dat[ind[pat[i][j][k]]].z) );
}
// rectangle check
inline int rectCheck(int i, int j)
{
int dis=disCalc(i, j, 0)-disCalc(i, j, 1); // =
int pro=(dat[ind[pat[i][j][1]]].x-dat[ind[pat[i][j][0]]].x)*(dat[ind[pat[i][j][3]]].x-dat[ind[pat[i][j][0]]].x)+
(dat[ind[pat[i][j][1]]].y-dat[ind[pat[i][j][0]]].y)*(dat[ind[pat[i][j][3]]].y-dat[ind[pat[i][j][0]]].y)+
(dat[ind[pat[i][j][1]]].z-dat[ind[pat[i][j][0]]].z)*(dat[ind[pat[i][j][3]]].z-dat[ind[pat[i][j][0]]].z); // +
return !(pro+dis);
}
// check sum
int check()
{
int i, ret;
for(i=ret=0; i<3; ++i)
{
if(rectCheck(i, 0) && rectCheck(i, 1))
ret+=faceCheck(i);
}
return ret>=3;
}
int main()
{
int t, x, y, z, i, j, f;
scanf("%d", &t);
assert(1<=t && t<=100);
while(t--)
{
for(i=0, ind.clear(), dat.clear(); i<8; ++i)
{
getchar();
scanf("(%d,%d,%d)", &x, &y, &z);
assert(-1000<=x && x<=1000);
assert(-1000<=y && y<=1000);
assert(-1000<=z && z<=1000);
ind.push_back(i);
dat.push_back(node(x, y, z));
}
for(i=0, f=1; i<8 && f; ++i)
{
for(j=i+1; j<8 && f; ++j)
{
if(dat[i]==dat[j]) f=0;
}
}
if(f)
{
f=0;
do{
f=check();
}while(!f && next_permutation(ind.begin(), ind.end()));
}
puts(f?"Yes":"No");
}
return 0;
}
C:the biggest number
#include "header.h"
const int N = 11;
vector<string> edg[N];
stack<int> path;
int in[N], ou[N], cur[N]; // cur 是当前狐
char s[N];
void dfs(int u)
{
int v = cur[u];
while(v<edg[u].size())
{
cur[u]++;
dfs(edg[u][v][edg[u][v].size()-1]-'0');
path.push(v*10+u);
v=cur[u];
}
}
inline bool cmp(string s1, string s2)
{
if (s1==s2) {return false;}
int i=0, j=0;
while(1)
{
if (s1[i]!=s2[j]) return s1[i]>s2[j];
if(i<s1.size()-1) ++i;
if(j<s2.size()-1) ++j;
}
}
int main()
{
int n, i;
while(~scanf("%d", &n) && n)
{
MM(in, 0); MM(ou, 0); MM(cur, 0);
FF(i,10) edg[i].clear();
while(!path.empty()) path.pop();
gets(s);
FF(i,n) { gets(s);
edg[s[0]-'0'].push_back(s);
ou[s[0]-'0']++;
in[s[strlen(s)-1]-'0']++;
}
FF(i,10)
sort(edg[i].begin(), edg[i].end(), cmp);
int cnt=0;
FF(i,10) { if(in[i]!=ou[i]) cnt++; }
if (cnt==0) FFD(i,10) if(ou[i]) break;
if (cnt==2) FF(i,10) if(ou[i]>in[i]) break;
dfs(i);
int j;
j=path.size();
if (path.size()==n)
{
while(!path.empty())
{
j = path.top(); path.pop();
printf("%s", edg[j%10][j/10].c_str());
}
}
else { printf("-1"); }
puts("");
}
return 0;
}
G:the second shortest path
#include "header.h"
vector< vector<PII> > edg;
vector<PII> dis;
priority_queue<PII, vector<PII>, greater<PII> > que;
int main()
{
int t, s, n, m, u, v, c, q;
SS(t);
while(t--) {
// build
scanf("%d%d%d", &s, &n, &m);
edg.clear(); edg.resize(n+n|1);
PII tmp;
while(m--) {
scanf("%d%d%d", &u, &v, &c);
tmp.second=c;
tmp.first = v; edg[u].push_back(tmp);
tmp.first = u; edg[v].push_back(tmp);
}
// dj
dis.clear(); dis.resize(n<<1|1);
tmp.first=tmp.second=inf;
fill(dis.begin(), dis.end(), tmp);
dis[s].first=0; ASA(que.empty());
tmp.first = 0; tmp.second = s;
que.push(tmp);
while(!que.empty()) {
tmp = que.top(); que.pop();
u = tmp.second;
if (!dis[u].second) { continue; }
dis[u].second = 0;
s = u; if (u>n) { u-=n; }
q = edg[u].size();
FF(m, q) {
v = edg[u][m].first;
c = edg[u][m].second;
if (dis[v].second && dis[v].first>dis[s].first+c) {
dis[v+n].first = dis[v].first;
que.push(make_pair(dis[v+n].first, v+n));
dis[v].first=dis[s].first+c;
que.push(make_pair(dis[v].first, v));
}
else if ( (dis[v].first!=dis[s].first+c) && dis[v+=n].second
&& (dis[v].first>dis[s].first+c) )
{
dis[v].first=dis[s].first+c;
que.push(make_pair(dis[v].first, v));
}
}
}
// q
SS(q); v=0;
while(q--) {
SS(u);
if(dis[u+n].second) printf("-1 ");
else PP(dis[u+n].first);
}
printf("\n");
}
return 0;
}