程序设计思维与实践 Week12 作业 (1/2/智能班)

A - 必做题 - 1

给出n个数，zjm想找出出现至少(n+1)/2次的数， 现在需要你帮忙找出这个数是多少？

Input

本题包含多组数据：

每组数据包含两行。

第一行一个数字N(1<=N<=999999) ，保证N为奇数。

第二行为N个用空格隔开的整数。

数据以EOF结束

Output

对于每一组数据，你需要输出你找到的唯一的数。

解题思路

先将数组进行排序，这样相同的数就会到一起，从第二个数开始遍历数组，看与前面是否相同，用sum对每个数进行计数，当sum=(n+1)/2时候就输出

#include<algorithm>
using namespace std;
int a[1000000], b[1000000];
int main()
{
	int n;
	while (cin >> n)
	{
		a[n] = -1111111;
		int ans = (n + 1) / 2;
		for (int i = 0; i < n; i++)
			cin >> a[i];
		sort(a, a + n);
		int sum = 1;
		for (int i = 1; i <= n; i++)
		{
			if (a[i] == a[i - 1])
				sum++;
			else
			{
				//cout << sum << endl;
				if (sum >= ans)
				{
					cout << a[i - 1]<<endl;
					break;
				}
				sum = 1;
			}

		}
	}

}

B - 必做题 - 2

zjm被困在一个三维的空间中,现在要寻找最短路径逃生！

空间由立方体单位构成。

zjm每次向上下前后左右移动一个单位需要一分钟，且zjm不能对角线移动。

空间的四周封闭。zjm的目标是走到空间的出口。

是否存在逃出生天的可能性？如果存在，则需要多少时间

Input

输入第一行是一个数表示空间的数量。

每个空间的描述的第一行为L，R和C（皆不超过30）。

L表示空间的高度，R和C分别表示每层空间的行与列的大小。
随后L层，每层R行，每行C个字符。

每个字符表示空间的一个单元。’#‘表示不可通过单元，’.'表示空白单元。

zjm的起始位置在’S’，出口为’E’。每层空间后都有一个空行。L，R和C均为0时输入结束

output

每个空间对应一行输出。

如果可以逃生，则输出如下

Escaped in x minute(s).

x为最短脱离时间。
如果无法逃生，则输出如下

Trapped!

解题思路

• 定义三个数组，用来表示前后左右上下移动

int mx[6] = { 1,-1,0,0,0,0 };
int my[6] = { 0,0,1,-1,0,0 };
int mz[6] = { 0,0,0,0,1,-1 };

• 用数组vis[i][j][k]来表示该点是否可以它通过，0表示可以，1表示不可以。
• 要找到最短逃生路则从起点开始使用广度优先搜索，如果找到终点输出相应的时间即可。

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
struct node {
	int z, x, y, weight;
	node()
	{
		z = x = y = weight = 0;
	}
	node& operator = (node p)
	{
		z = p.z;
		x = p.x;
		y = p.y;
		weight = p.weight;
	}
};
int mx[6] = { 1,-1,0,0,0,0 };
int my[6] = { 0,0,1,-1,0,0 };
int mz[6] = { 0,0,0,0,1,-1 };
int vis[35][35][35];
int l, r, c;
int main()
{
	cin >> l >> r >> c;
	while (l != 0 && r != 0 && c != 0)
	{
		node st, en;
		char sp;
		for (int i = 1; i <= l; i++)
		{
			for (int j = 1; j <= r; j++)
			{
				for (int k = 1; k <= c; k++)
				{
					cin >> sp;
					if (sp == 'S')
					{
						vis[i][j][k] = 1;
						st.z = i;
						st.x = j;
						st.y = k;
					}
					else if (sp == 'E')
					{
						vis[i][j][k] = 0;
						en.z = i;
						en.x = j;
						en.y = k;
					}
					else if (sp == '#')
						vis[i][j][k] = 1;
					else
						vis[i][j][k] = 0;

				}
			}
			}
		queue<node> q;
		q.push(st);
		vis[st.z][st.x][st.y] = 1;
		bool ok = false;
		int ans = 0;
		while (!q.empty())
		{
			node tmp = q.front();
			q.pop();
			if ((tmp.z == en.z) && (tmp.x == en.x) && (tmp.y == en.y))
			{
				ok = true;
				ans = tmp.weight;
				break;
			}
			for (int i = 0; i < 6; i++)
			{
				int newz = tmp.z + mz[i];
				int newx = tmp.x + mx[i];
				int newy = tmp.y + my[i];
				if (newz >= 1 && newz <= l && newx >= 1 && newx <= r && newy >= 1 && newy <= c && vis[newz][newx][newy] == 0)
				{
					node te;
					te.z = newz;
					te.x = newx;
					te.y = newy;
					te.weight = tmp.weight + 1;
					vis[newz][newx][newy] = 1;
					q.push(te);
				}
			}
		}
		if (ok)
			cout << "Escaped in " << ans << " minute(s)." << endl;
		else
			cout << "Trapped!" << endl;
		cin >> l >> r >> c;
	}
}			
						

C - 必做题 -3

东东每个学期都会去寝室接受扫楼的任务，并清点每个寝室的人数。

每个寝室里面有ai个人(1<=i<=n)。从第i到第j个宿舍一共有sum(i,j)=a[i]+…+a[j]个人

这让宿管阿姨非常开心，并且让东东扫楼m次，每一次数第i到第j个宿舍sum(i,j)
问题是要找到sum(i1, j1) + … + sum(im,jm)的最大值。且ix <= iy <=jx和ix <= jy <=jx的情况是不被允许的。也就是说m段都不能相交。
注：1 ≤ i ≤ n ≤ 1e6 , -32768 ≤ ai ≤ 32767 人数可以为负数。。。。。(1<=n<=1000000)

Input

输入m，输入n。后面跟着输入n个ai
处理到 EOF

Output

输出最大和

解题思路

动态规划问题,定义dp[i][j]为前j个宿舍取i组获得的最大值，第j个宿舍必须包含在其中；状态转移方程：

dp[i][j]=max{dp[i][j−1],max(dp[i−1][k],1≤k≤j−1)}+A[j]

1，即考虑加入宿舍j，第一种情况是j加入最后一组，dp[i][j-1]直接加上A[j]。

2，第二种情况是j自己成为一组，加上前边的j-1个宿舍（可以不包含j-1）分成,i-1组的最大值。

由于数据范围太大，我们考虑降到一维。对于这个最大值，我们用p[]保存，dp[i]表示取到第i个房间的最大值；

#include<bits/stdc++.h>
using namespace std;
const int maxn1=1e9;
const int maxn2=1e6+10;
int a[maxn2];
int dp[maxn2],p[maxn2];
int m,n,ans;

int main()
{
	while(scanf("%d%d",&m,&n)!=EOF){
		ans=0;
		memset(dp,0,sizeof(dp));
		memset(p,0,sizeof(p));
		for(int i=1;i<=n;i++)scanf("%d",&a[i]);
		
		for(int i=1;i<=m;i++){//层数 
			ans=-maxn1;
			for(int k=i;k<=n;k++){//最右边界； 
				dp[k]=max(dp[k-1]+a[k],p[k-1]+a[k]);
				p[k-1]=ans;
				ans=max(ans,dp[k]);//保证是当前层最大值； 
			}
			} 
		printf("%d\n",ans);	
	}
	return 0;
 }