20161102的考试】模拟，树的直径，推公式……三道水题然而浪飞了……

…………喵的……今天太浪了23333

三道题都会三道都GG【滚走

…………喵的…………在AK场没上百是怎样的体验*2

T1自信不对拍，然后发现好像自己naive了；

T2……喵的我fread开小了于是RE【智障脸

T3………………题意理解错*1，瞬间心态爆炸GGGGGGGG

T1：

题面：模拟一下连连看，找每个块有多少能和它消除的

思路：……模拟啊模拟，喵哒似乎是状态稍微记少了一点，反正是水题随便写写就能过的，比起dfs果然还是bfs比较好看

代码：

#include<bits/stdc++.h>
#define MAXN 36
#define INF 0x3f3f3f3f
#define push(a,b,c) que[tail++]=a,que[tail++]=b,que[tail++]=c
using namespace std;	int n,m;
const int cx[4] = {-1,0,1,0};
const int cy[4] = {0,1,0,-1};

int gph[MAXN][MAXN];
int cnt[MAXN][MAXN];

const int MAXQ = MAXN*MAXN*12;
int que[MAXQ],head,tail;

int dis[MAXN][MAXN][4];

inline void bfs(int x,int y){
	if(!gph[x][y])	return ;
	int x0=x,y0=y;
	memset(dis,INF,sizeof dis);
	head=tail=0;
	for(int dir=0;dir<4;++dir)
		dis[x][y][dir]=0,push(x,y,dir);

	int pre_dir;
	while(head^tail){
		x=que[head++],y=que[head++],pre_dir=que[head++];
		if(head==MAXQ)	head=0;
		
		if(dis[x][y][pre_dir]>=3)	continue;
		
		for(int dir=0;dir<4;++dir){
			int xx=x+cx[dir],yy=y+cy[dir];
			if(xx<0||xx>n+1||yy<0||yy>m+1)	continue;
			for(int dir2=0;dir2<4;++dir2){
				if(dis[xx][yy][dir2] > dis[x][y][pre_dir]+((pre_dir^dir)&1)+((dir^dir2)&1)){
					dis[xx][yy][dir2] = dis[x][y][pre_dir]+((pre_dir^dir)&1)+((dir^dir2)&1);
					if(!gph[xx][yy]){
						push(xx,yy,dir2);
						if(tail==MAXQ)	tail=0;
					}
				}
			}
		}
	}
	
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j)
			if((i^x0)||(j^y0))
				if(gph[i][j]==gph[x0][y0]&&(dis[i][j][0]<3||dis[i][j][1]<3||dis[i][j][2]<3||dis[i][j][3]<3))
					++cnt[x0][y0];
}

int main(){
	freopen("game.in","r",stdin);
	freopen("game.out","w",stdout);
	
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j)
			scanf("%d",&gph[i][j]);
	
	for(int i=1;i<=n;++i)
		for(register int j=1;j<=m;++j)
			bfs(i,j);
	
	for(int i=1;i<=n;++i)
		for(register int j=1;j<=m;++j)
			printf("%d%c",cnt[i][j],j==m?'\n':' ');
	return 0;
}

T2：

题面：遍历树上的所有节点，求最短路径

思路：显然可以有一条路径只走一遍，其他的都要走两遍，只走一遍的选直径肯定最优，注意1e6可能卡栈空间，bfs就好了

代码：

#include<bits/stdc++.h>
#define MAXN 1000005
using namespace std;	int n;

int root;

struct t1{
	int to,nxt,lth;
}edge[MAXN<<1];	int cnt_edge;
int fst[MAXN];
void addedge(int x,int y,int lth){
	edge[++cnt_edge].to=y;
	edge[cnt_edge].nxt=fst[x];
	edge[cnt_edge].lth=lth;
	fst[x]=cnt_edge;
	
	edge[++cnt_edge].to=x;
	edge[cnt_edge].nxt=fst[y];
	edge[cnt_edge].lth=lth;
	fst[y]=cnt_edge;
}

long long dis[MAXN];
int fth[MAXN];

int que[MAXN<<1],head,tail;
int bfs(int now){
	int rtn = now;
	
	head=tail=0;
	memset(fth,0,sizeof fth);
	
	dis[now]=0;
	
	que[tail++]=now;
	while(head^tail){
		now=que[head++];
		for(int tmp=fst[now];tmp;tmp=edge[tmp].nxt){
			int aim=edge[tmp].to;
			if(aim==fth[now])	continue;
			fth[aim] = now;
			dis[aim] = dis[now] + edge[tmp].lth;
			if(dis[aim] > dis[rtn])	rtn = aim;
			que[tail++]=aim;
		}
	}
	return rtn;
}

long long ans=0;

int read_x,read_y,read_lth;
int main(){
	freopen("journey.in","r",stdin);
	freopen("journey.out","w",stdout);
	
	srand(20000218);
	
	scanf("%d",&n);
	root=rand()%n+1;
	
	for(int i=1;i<n;++i)
		scanf("%d%d%d",&read_x,&read_y,&read_lth),
		ans += read_lth,
		addedge(read_x,read_y,read_lth);
	
	ans<<=1ll;
	root=bfs(root);
	int r2=bfs(root);
	printf("%lld",ans - dis[r2]);
	
	return 0;
}

T3：

题面：

一条路长度为D，从起点走到终点，每秒会减少A的血量（0.1秒减少0.1A的那种方式），在每一整秒的末尾可以增加一定血量，如果在任一瞬间血量小于0就失败。每获得1的初始血量需要G1的代价，每获得1的速度需要G2的代价（速度必须小于等于D），每获得1的回复量需要G3的代价，求最小花费。D和A都是1e6的，G1 G2 G3都是200的。

思路：

显然推公式，枚举速度v的取值，如果选初始血量比回复更优，肯定就全部氪在G1上，初始血量氪（ceil(A*D/v)），如果回复更优，肯定初始血量就是A，之后每秒回复也是A，对于每个速度直接把上面那两个值取min就好了，根本不需要什么分类讨论【果然还是我菜了233333】

注意因为血是每秒递减的，所以上取整操作要对（A*(D/v)）整个进行

代码：

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;	long long A,D,G1,G2,G3;

int main(){
	freopen("run.in","r",stdin);
	freopen("run.out","w",stdout);
	
	scanf("%lld%lld%lld%lld%lld",&D,&A,&G1,&G2,&G3);

	long long ans=INF;
	
	long long tt=A*G1+A*G3;
	for(int b=1;b<=D;++b)
		ans=min(ans,b*G2+min(tt,(long long)(ceil((double)A*D/b)*G1)));
	
	printf("%lld",ans);
	return 0;
}