福州大学第十二届程序设计竞赛（部分题解）

时间：2015-05-04 18:16:01 阅读：238 评论：0 收藏：0 [点我收藏+]

比赛链接：http://acm.fzu.edu.cn/contest/list.php?cid=144

Problem B 完美的数字
Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

Bob是个很喜欢数字的孩子，现在他正在研究一个与数字相关的题目，我们知道一个数字的完美度是把这个数字分解成三个整数相乘A*A*B（0<A<=B）的方法数，例如数字80可以分解成1*1*80，2*2*20 ，4*4*5，所以80的完美度是3；数字5只有一种分解方法1*1*5，所以完美度是1，假设数字x的完美度为d(x)，现在给定a，b（a<=b），请你帮Bob求出

S，S表示的是从a到b的所有数字的流行度之和，即S=d(a)+d(a+1)+…+d(b)。

Input

输入两个整数a，b（1<=a<=b<=10^15）

Output

输出一个整数，表示从a到b的所有数字流行度之和。

Sample Input

1 80

Sample Output

107

题目分析：枚举到B^(1/3)即可，首先每个数字的完美度至少为1，因为x/(i*i) (i >= 2)必须大于i才满足A*A*B（0<A<=B），所以对于每个可能的枚举值的额外完美度为x/(i*i)-i+1

#include <cstdio>
#include <cstring>
#define ll long long

ll cal(ll x)
{
	ll cnt = 0;
	for(ll i = 2; i * i * i <= x; i++)
		cnt += x / (i * i) - i + 1;
	return x + cnt;
}

int main()
{
	ll a, b;
	while(scanf("%I64d %I64d", &a, &b) != EOF)
		printf("%I64d\n", cal(b) - cal(a - 1));
}

Problem D So Hard

Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

请将有限小数化为最简分数。

Input

一个整数n 表示需要转化的小数个数；接下来n行，每行有一个有限小数。（保证小数位数不超过9位）

Output

输出有n行，每行为小数对应的最简分数

Sample Input

2
0.5
0.4

Sample Output

1/2
2/5

Hint

注意精度问题，数据保证不会有类似1.0的小数。

题目分析：字符串读，分子分母同除他们的最大公约数

#include <cstdio>
#include <cstring>
#define ll long long
int const MAX = 1e5;
char s[MAX];

ll gcd(int a, int b)
{
	return b ? gcd(b, a % b) : a;  
}

int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		scanf("%s", s);
		int l = strlen(s);
		ll len = 1;
		ll num = 0;
		bool flag = false;
		for(int i = 0; i < l; i++)
		{
			if(s[i] == '.')
			{
				flag = true;
				continue;
			}
			num = num * 10 + (s[i] - '0');
			if(flag)
				len *= 10;
		}
		ll g = gcd(num, len);
		printf("%I64d/%I64d\n", num / g, len / g);
	}
}

Problem F 检查站点

Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

在山上一共有N个站点需要检查，检查员从山顶出发去各个站点进行检查，各个站点间有且仅有一条通路，检查员下山前往站点时比较轻松，而上山时却需要额外的时间，问最后检查员检查完所有站点时所需要的额外时间最少是多少。技术分享

Input

包含多组数据每组数据输入第一行为一个整数N 表示站点个数（1<=N<=100000）,接下去N-1 行每行3个整数 x，y，z(1<=z<=10000) 检查站x为检查站y的父节点，x,y之间有一条通路，从y到x需要额外z的时间。（父节点在子节点上方，山顶固定标号为1）

Output

输出一行一个整数表示最少需要花费的额外时间。

Sample Input

6
1 2 1
2 4 1
1 3 1
3 5 1
3 6 1

Sample Output

3

题目分析：全部值减去权值最大的一条从根到叶子的路径值即可

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const MAX = 1e5 + 5;
int re[MAX], fa[MAX];
int n;

int get_num(int v)
{
	int cnt = 0;
	for(; v; v = fa[v])
		cnt += re[v];
	return cnt;
}

int main()
{
	while(scanf("%d", &n) != EOF)
	<span style="font-size:14px;">{
		memset(re, 0, sizeof(re));
		memset(fa, 0, sizeof(fa));
		int sum = 0;
		for(int i = 0; i < n - 1; i++)
		{
			int u, v, w;
			scanf("%d %d %d", &u, &v, &w);
			fa[v] = u;
			re[v] = w;
			sum += w;
		}
		int ma = 0;
		for(int i = 2; i <= n; i++)
			ma = max(ma, get_num(i));
		printf("%d\n", sum - ma);
	}
}</span>

Problem G Escape

Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

小明进入地下迷宫寻找宝藏，找到宝藏后却发生地震，迷宫各处产生岩浆，小明急忙向出口处逃跑。如果丢下宝藏，小明就能迅速离开迷宫，但小明并不想轻易放弃自己的辛苦所得。所以他急忙联系当程序员的朋友你（当然是用手机联系），并告诉你他所面临的情况，希望你能告诉他是否能成功带着宝藏逃脱。

Input

有多组测试数据。

每组测试数据第一行是一个整数T,代表接下去的例子数。（0<=T<=10）

接下来是T组例子。

每组例子第一行是两个整数N和M。代表迷宫的大小有N行M列（0<=N,M<=1000）。

接下来是一个N*M的迷宫描述。

S代表小明的所在地。

E代表出口,出口只有一个。

.代表可以行走的地方。

！代表岩浆的产生地。（这样的地方会有多个,其个数小于等于10000）

#代表迷宫中的墙，其不仅能阻挡小明前进也能阻挡岩浆的蔓延。

小明携带者宝藏每秒只能向周围移动一格，小明不能碰触到岩浆（小明不能和岩浆处在同一格）。

岩浆每秒会向四周不是墙的地方蔓延一格。

小明先移动完成后，岩浆才会蔓延到对应的格子里。

小明能移动到出口，则小明顺利逃脱。

Output

每组测试数据输出只有一行“Yes”或者“No”。“Yes”代表小明可以成功逃脱。否则输出“No”。

Sample Input

3
5 5
....!
S....
#....
!#...
#E...
2 2
S.
!E
2 2
SE
!.

Sample Output

Yes
No
Yes

题目分析：BFS1预处理各个点岩浆到达的最短时间，BFS2搜人是否能出去，要注意的一点是如果人和岩浆同时到E，则人算成功逃脱

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
int const MAX = 1005;
int const INF = 0x7fffffff;
char map[MAX][MAX];
int tim[MAX][MAX];
bool vis[MAX][MAX];
int n, m;
int sx, sy, ex, ey;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};

struct NODE
{
	int x, y;
	int step;
};

bool ok(int i, int j)
{
	if(i >= 0 && j >= 0 && i < n && j < m)
		return true;
	return false;
}

void BFS1()
{	
	NODE yj;
	queue <NODE> q;
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < m; j++)
		{
			if(map[i][j] == '!')
			{
				yj.x = i;
				yj.y = j;
				yj.step = 0;
				tim[i][j] = 0;
				q.push(yj);
			}
		}
	}
	while(!q.empty())
	{
		NODE now = q.front(), t;
		q.pop();
		//printf("now.x = %d  now.y = %d  now.step = %d\n", now.x, now.y, now.step);
		for(int i = 0; i < 4; i ++)
		{
			t.x = now.x + dx[i];
			t.y = now.y + dy[i];
			t.step = now.step + 1;
			if(ok(t.x, t.y) && t.step < tim[t.x][t.y])
			{
				tim[t.x][t.y] = t.step;
				q.push(t);
			}
		}
	}
	return;
}

bool BFS2()
{	
	memset(vis, false, sizeof(vis));
	NODE st;
	st.x = sx;
	st.y = sy;
	vis[sx][sy] = true;
	st.step = 0;
	queue <NODE> qq;
	qq.push(st);
	while(!qq.empty())
	{
		NODE now = qq.front(), t;
		qq.pop();
		if(now.x == ex && now.y == ey && t.step <= tim[t.x][t.y])
			return true;
		for(int i = 0; i < 4; i++)
		{
			t.x = now.x + dx[i];
			t.y = now.y + dy[i];
			t.step = now.step + 1;
			if(t.x == ex && t.y == ey && t.step <= tim[t.x][t.y])
				return true;
			if(ok(t.x, t.y) && !vis[t.x][t.y] && t.step < tim[t.x][t.y])
			{
				vis[t.x][t.y] = true;
				qq.push(t);
			}
		}
	}
	return false;
}

int main()
{
	int T;
	while(scanf("%d", &T) != EOF)
	{
		while(T--)
		{
			scanf("%d %d", &n, &m);
			if(n == 0 || m == 0)
			{
				printf("No\n");
				continue;
			}
			for(int i = 0; i < n; i++)
			{
				scanf("%s", map[i]);
				for(int j = 0; j < m; j++)
				{
					tim[i][j] = INF;
					if(map[i][j] == 'S')
					{
						sx = i;
						sy = j;
					}
					if(map[i][j] == 'E')
					{
						ex = i;
						ey = j;
					}
					if(map[i][j] == '#')
						tim[i][j] = 0;
				}
			}
			BFS1();
			printf("%s\n", BFS2() ? "Yes" : "No");
		}
	}
}

Problem 2197 最小花费

Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

给一个长度为n（n <= 10^5）的“01”串，你可以任意交换一个为0的位和一个为1的位，若这两位相邻，花费为X，否则花费为Y。求通过若干次交换后将串中的“1”全部变换到“0”前面的最小花费。

Input

第一行一个整数T（1 <= T <= 10），表示测试数据的组数。接下来3*T行，每组数据三行，第一行为整数X（1 <= X <= 10^3），第二行为整数Y(X <= Y <= 10^3)，第三行是“01”串。

Output

最小花费。

Sample Input

2
1
2
1100
1
2
0011

Sample Output

0
3

题目分析：两种策略，跨着换，相邻换，首先相邻换的花费是固定的，所以一个1和一个0，要交换的花费为min(y, x * len)
先处理处所有1的位置和个数cnt，我们要让前cnt均为1，则从0到cnt－1枚举，遇到一个0则拿最后的一个1和它交换

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const MAX = 1e5;
char s[MAX];
int idx[MAX];

int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		int x, y;
		scanf("%d %d",&x, &y);
		scanf("%s", s);
		int len = strlen(s), cnt = 0;
		for(int i = len - 1; i >= 0; i--)
			if(s[i] == '1')
				idx[cnt ++] = i;
		int ans = 0, now = 0;
		for(int i = 0; i < cnt; i++)
			if(s[i] == '0')
				ans += min(y, x * (idx[now ++] - i));
		printf("%d\n", ans);
	}
}

福州大学第十二届程序设计竞赛（部分题解）

标签：福州大学第十二届程序设计竞赛

原文地址：http://blog.csdn.net/tc_to_top/article/details/45481713

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

福州大学第十二届程序设计竞赛 （部分题解）

比赛链接：http://acm.fzu.edu.cn/contest/list.php?cid=144

Problem B 完美的数字 Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

Input

Output

Sample Input

Sample Output

Problem Description

Input

Output

Sample Input

Sample Output

Hint

Problem Description

Input

Output

Sample Input

Sample Output

Problem Description

Input

Output

Sample Input

Sample Output

Problem Description

Input

Output

Sample Input

Sample Output

福州大学第十二届程序设计竞赛（部分题解）

Problem B 完美的数字
Time Limit: 1000 mSec Memory Limit : 32768 KB