深圳大学2012年程序设计比赛解题报告

首先给出红榜哈

接下来看看各题做题情况

然后看看各题解法吧..

*代表题目难度

Problem A Find the Dragon
**
第一题，有点见龙在田的味道...

给出一个长串，问它的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;
}