week12-作业-必做题

A-必做题-1

题目：

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

Input：

本题包含多组数据：
每组数据包含两行。
第一行一个数字N(1<=N<=999999) ，保证N为奇数。
第二行为N个用空格隔开的整数。
数据以EOF结束。

Output：

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

Sample Input：

5
1 3 2 3 3
11
1 1 1 1 1 5 5 5 5 5 5
7
1 1 1 1 1 1 1

Sample Output：

3
5
1

题目分析：

简单地根据题意，记录下每组数据的N个数中每个数出现的个数，用数组cnt存储，并且记录下数据范围的minn和maxx，然后对minn-maxx中的数遍历，直到找到cnt[i]>=（n+1)/2，输出相对应的i即可。

但是这个题对时间和空间复杂度卡的比较严，需要注意，对于输入的n个数就不需要再用一个数组存储了，直接变量即可，否则会报runtimeerror，以及注意数据范围（不要像我一样，瞅着六个0，开了7个0的空间。。一直报Memory Limit Exceed！！）

代码：

#include
#include
#include
#include
using namespace std;
const int inf=1e8+8;
const int maxn=1000010;
int cnt[maxn];
int main()
{
	int n;int a;
	while(scanf("%d",&n)!=EOF)
	{
		int maxx=0;int minn=inf;
		memset(cnt,0,sizeof(cnt));
		for(int i=0;i<n;i++)
		{
			cin>>a;
			maxx=max(maxx,a);
			minn=min(minn,a);
			cnt[a]++; 
		} 	
		for(int i=minn;i<=maxx;i++)
		{
			if(cnt[i]>=(n+1)/2)
			{
				cout<<i<<endl;
				break;
			}
		}	
	}
	return 0;
} 

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!

Sample Input

3 4 5
S….
.###.
.##..
###.#
#####
#####
##.##
##…
#####
#####
#.###
####E
1 3 3
S##
#E#
###
0 0 0

Sample Output：

Escaped in 11 minute(s).
Trapped!

题目分析：

该题和之前的迷宫问题很相似，只是从二维改成了三维。仍然采用bfs的方法，首先让起点入队，然后遍历其向外走的所有方式，找到能走的所有方案，并记得步数+1；直到走到终点，如果能走到终点，按照输出格式输出此时的步长，否则的话，代表无法逃脱，按照输出格式输出Trapped!

（我觉得我可能最近真的有点眼瞎。。把vis[next.x][next.y][next.z]写成vis[next.x][next.y][next.x]，导致报错Time Limit Exceed！硬是找了一晚上的错，窒息）

代码：

#include
#include
#include
#include
#include
using namespace std;
const int maxn=32;
struct point//三维坐标 
{
	int x;
	int y;
	int z;
	int step;
}; 
char a[maxn][maxn][maxn];
bool vis[maxn][maxn][maxn];

int dx[]={0,0,1,-1,0,0};
int dy[]={1,-1,0,0,0,0};
int dz[]={0,0,0,0,1,-1};

point start;point end;
int l,r,c;

bool flag=false;
queue<point> q;//队列 

void bfs()
{
	while(q.size()) q.pop();
	memset(vis,false,sizeof(vis));//初始化为flase  
	q.push(start);
	vis[start.x][start.y][start.z]=true;
	while(!q.empty())//当队列不为空时 
	{
		point temp=q.front();//取出队列首元素
		q.pop();	
		if(temp.x==end.x && temp.y==end.y && temp.z==end.z)//到达终点 
		{
			flag=true;
			cout<<"Escaped in "<<temp.step<<" minute(s)."<<endl;
			return ;
		}
		for(int i=0;i<6;i++)	//向外走 
		{
			point next;
			next.x=temp.x+dx[i];
			next.y=temp.y+dy[i];
			next.z=temp.z+dz[i];
			if( next.x>=0&&next.x<l && next.y>=0&&next.y<r && next.z>=0&&next.z<c 
			&&!vis[next.x][next.y][next.z] && a[next.x][next.y][next.z]!='#')
			{
				vis[next.x][next.y][next.z]=true;//被标记为已访问 
				next.step=temp.step+1;
				q.push(next); 
			}		
		} 
	}
}
int main()
{
	while(cin>>l>>r>>c)//L表示空间的高度，R和C分别表示每层空间的行与列的大小
	{
		if(l==0&&r==0&&c==0)
		{
			break;
		}
		for(int i=0;i<l;i++)
		{
			for(int j=0;j<r;j++)
			{
				for(int k=0;k<c;k++)
				{
					cin>>a[i][j][k];
					if(a[i][j][k]=='S')
					{
						start.x=i;
						start.y=j;
						start.z=k;
						start.step=0;
					}
					if(a[i][j][k]=='E')
					{
						end.x=i;
						end.y=j;
						end.z=k;
						end.step=0;
					}
				}
			}
		}	
		flag=false;
		bfs();	
		if(!flag)
		{
			cout<<"Trapped!"<<endl;	
		} 
	}
	return 0;
}

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 。

Output:

输出最大和 。

Sample Input:

1 3 1 2 3
2 6 -1 4 -2 3 -2 3

Sample Output:

6
8 

Hint

数据量很大，需要scanf读入和dp处理。

题目分析：

该题要求最大的和，因为存在负数且数据量很大,所以需要用到动态规划的思想。

转移方程为 dp[i][j]=max(dp[i][j-1]+a[j],dp[i-1][k]+a[j])，前者表示的是延续上一个区间，加上第j个区间，后者表示，另起一个新的区间，以第j个区间为起始区间。

优化:因为dp[i-1][k]只在dp[i][j]的更新中出现，所以可以优化成滚动数组一维形式，另用一个数组pre表示上一个状态中的dp最大值。转移方程就变成了 dp[j]=max(dp[j-1]+a[j],pre[j-1]+a[j])。注意这里的pre是用于下一个dp的更新，不能影响当前dp，所以位置应在dp更新之后。

代码：

#include
#include
#include
using namespace std;
const int maxn=1e6+5;
const int inf=1e8+8;
int dp[maxn];//i-j的最大值 
int pre[maxn];//前一个状态中的dp最大值 
int main()
{
	int m,n;
	while(scanf("%d%d",&m,&n)!=EOF)
	{
		int *a=new int[n];
		int ans=-inf;
		for(int i=0;i<n;i++)
		{
			scanf("%d",&a[i]);
		}
		for(int i=0;i<n;i++)
		{
			dp[i]=0;
			pre[i]=0;
		}
		for(int i=0;i<m;i++)
		{
			ans=-inf;
			for(int j=i;j<n;j++)
			{
				dp[j]=max(dp[j-1]+a[j],pre[j-1]+a[j]);
				pre[j-1]=ans;
				ans=max(ans,dp[j]);
			}
		} 
		cout<<ans<<endl;
	}
	return 0;
 }