Week2-程序设计思维与实践

最新推荐文章于 2024-07-29 22:05:42 发布
最新推荐文章于 2024-07-29 22:05:42 发布
阅读量339 收藏
点赞数
文章标签： c++ 数据结构 算法
by Russellwzr
本文链接：https://blog.csdn.net/weixin_44771757/article/details/104574179
版权

作业题

题目地址

A-Maze

  • 题意：
    经典迷宫问题，输入5×5的二维数组表示迷宫，0表示可以走，1表示不可以走，要求输出从入口
    （0，0）到出口（4，4）的最短路径。
  • 思路：
    BFS板子题，为了记录路径，在结构体中添加记录父节点的变量，使用以head、tail指针维护的结构体数组作为队列，先将（0，0）入队，从起点开始，执行一次BFS直到队头元素为终点结束，然后从此时的队头元素开始，向前回溯直到父节点为起点为止以记录下路径，最后输出路径。
  • 代码实现：
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
using namespace std;

bool maze[5][5];
bool vis[5][5];
int dis[][2]={{1,0},{-1,0},{0,-1},{0,1}};

struct s{
	int x,y,father,steps;
	s(){}	
	s(int xx,int yy,int ff,int ss):x(xx),y(yy),father(ff),steps(ss){}
};

bool Range(int x,int y){
	if(x>=0&&x<=4&&y>=0&&y<=4&&maze[x][y]==0&&vis[x][y]==0)
		return true;
	return false;
}

int main()
{
	for(int i=0;i<5;i++){
		for(int j=0;j<5;j++){
			cin>>maze[i][j];
		}
	}
	memset(vis,0,sizeof(vis));
	s q[10000];
	int head=0;
	int tail=0;
	q[tail++]=s(0,0,-1,0);
	vis[0][0]=1;
	while(head!=tail){
		s t=q[head];
		if(t.x==4&&t.y==4){
			break;
		}
		for(int i=0;i<4;i++){
			int dx=t.x+dis[i][0];
			int dy=t.y+dis[i][1];
			if(Range(dx,dy)){
				vis[dx][dy]=1;
				q[tail++]=s(dx,dy,head,t.steps+1);
			}
		}
		head++;
	}
	vector<s> res;
	s tmp=q[head];
	while(tmp.father!=-1){
		res.push_back(tmp);
		tmp=q[tmp.father];
	}
	cout<<"(0, 0)"<<endl;
	for(int i=res.size()-1;i>=0;i--){
		cout<<"("<<res[i].x<<", "<<res[i].y<<")"<<endl;
	} 
	return 0;
}
  • DFS + STACK
#include <bits/stdc++.h>
using namespace std;
const int inf=1e9;
int maze[10][10],dis[][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool vis[10][10]; 

bool Range(int x,int y){
	if(x>=0&&x<=4&&y>=0&&y<=4&&maze[x][y]==0&&vis[x][y]==0)
	 	return true;
	return false;
}

struct node{
	int x,y;
	node(){}
	node(int xx,int yy):x(xx),y(yy){}
};

vector<node> path;

bool dfs(int x,int y){
	if(x==4&&y==4){
		path.push_back(node(x,y));
		return true;
	}
	vis[x][y]=1;
	bool flag=false;
	if(Range(x,y+1)&&dfs(x,y+1)||Range(x+1,y)&&dfs(x+1,y)||
            Range(x-1,y)&&dfs(x-1,y)||Range(x,y-1)&&dfs(x,y-1)){
		path.push_back(node(x,y));
        return true;
    }
	return false;
}

int main()
{
	for(int i=0;i<5;i++){
		for(int j=0;j<5;j++){
			scanf("%d",&maze[i][j]);
			vis[i][j]=0;
		}
	}
	vis[0][0]=1;
	dfs(0,0);
	for(int i=path.size()-1;i>=0;i--)
		printf("(%d, %d)\n",path[i].x,path[i].y);
	return 0;
}
  • DFS + 记录临时路径
#include <bits/stdc++.h>
using namespace std;
const int inf=1e9;
const int maxn=1e4;
int ans=inf,maze[10][10],dis[][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool vis[10][10]; 

bool Range(int x,int y){
	if(x>=0&&x<=4&&y>=0&&y<=4&&maze[x][y]==0&&vis[x][y]==0)
	 	return true;
	return false;
}

struct node{
	int x,y;
	node(){}
	node(int xx,int yy):x(xx),y(yy){}
};

node path[maxn],tmp[maxn];

void dfs(int x,int y,int steps){
	if(x==4&&y==4){
		if(ans>steps){
			ans=steps;
			tmp[steps].x=x;
			tmp[steps].y=y;
			for(int i=1;i<=steps;i++)
				path[i]=tmp[i];
		}
		return;
	}
	for(int i=0;i<4;i++){
		int dx=x+dis[i][0];
		int dy=y+dis[i][1];
		if(Range(dx,dy)){
			tmp[steps].x=x;
			tmp[steps].y=y;
			vis[dx][dy]=1;
			dfs(dx,dy,steps+1);
			vis[dx][dy]=0;
		}
	}
}

int main()
{
	for(int i=0;i<5;i++){
		for(int j=0;j<5;j++){
			scanf("%d",&maze[i][j]);
			vis[i][j]=0;
		}
	}
	vis[0][0]=1;
	dfs(0,0,0);
	for(int i=0;i<=ans;i++)
		printf("(%d, %d)\n",path[i].x,path[i].y);
	return 0;
}

B-Pour Water

  • 题意：
    有两个体积分别为A、B的容器，容器的起始状态为空，要求通过执行fill a/b、empty a(b) b(a)、pour a(b) b(a)六种操作使其中一个容器中装有体积为C的水，记录并输出操作过程
  • 思路：
    BFS隐式图问题，以两个容器中盛有水的体积作为本题的状态则初始结点为(0,0)，目标结点为(C,0)或(0,C)，中间结点为经过不同操作后容器中的盛水状态，实现思路与A题相似，从初始结点开始执行一次BFS直到队头元素为目标结点，从此时的队头元素开始向前回溯记录路径，最后输出操作过程。
  • 代码实现：
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
using namespace std;

int a,b,c;
bool vis[1010][1010];

struct s{
	int pot1;
	int pot2;
	int steps;
	int op;
	int father;
	s(){}
	s(int p1,int p2,int s,int o,int f):pot1(p1),pot2(p2),steps(s),op(o),father(f){}
};

s q[1000000];

void Output(int op){
	switch(op){
		case 0:
			cout<<"fill A"<<endl;
			break;
		case 1:
			cout<<"fill B"<<endl;
			break;
		case 2:
			cout<<"empty A"<<endl;
			break;			
		case 3:
			cout<<"empty B"<<endl;
			break;
		case 4:
			cout<<"pour A B"<<endl;
			break;
		case 5:
			cout<<"pour B A"<<endl;
			break;										
	}
}


int main()
{
	ios::sync_with_stdio(false);
	while(cin>>a>>b>>c){
		memset(vis,0,sizeof(vis));
		int head,tail;
		head=tail=0;
		vis[0][0]=1;
		q[tail++]=s(0,0,0,-1,-1);
		while(head!=tail){
			s t=q[head];
			if(t.pot1==c||t.pot2==c){
				break;
			}
			if(!vis[a][t.pot2]){
				vis[a][t.pot2]=1;
				q[tail++]=s(a,t.pot2,t.steps+1,0,head);
			}
			if(!vis[t.pot1][b]){
				vis[t.pot1][b]=1;
				q[tail++]=s(t.pot1,b,t.steps+1,1,head);
			}
			if(!vis[0][t.pot2]){
				vis[0][t.pot2]=1;
				q[tail++]=s(0,t.pot2,t.steps+1,2,head);
				
			}
			if(!vis[t.pot1][0]){
				vis[t.pot1][0]=1;
				q[tail++]=s(t.pot1,0,t.steps+1,3,head);				
			}
			int sum=t.pot1+t.pot2;
			if(sum>b){
				if(!vis[sum-b][b]){
					vis[sum-b][b]=1;
					q[tail++]=s(sum-b,b,t.steps+1,4,head);
				}
			}
			if(sum<=b){
				if(!vis[0][sum]){
					vis[0][sum]=1;
					q[tail++]=s(0,sum,t.steps+1,4,head);
				}
			}
			if(sum>a){
				if(!vis[a][sum-a]){
					vis[a][sum-a]=1;
					q[tail++]=s(a,sum-a,t.steps+1,5,head);
				}
			}
			if(sum<=a){
				if(!vis[sum][0]){
					vis[sum][0]=1;
					q[tail++]=s(sum,0,t.steps+1,5,head);
				}
			}			
			head++;
		}
		vector<s> res;
		s path=q[head];
		while(path.father!=-1){
			res.push_back(path);
			path=q[path.father];
		}
		for(int i=res.size()-1;i>=0;i--){
			Output(res[i].op);
		}
		cout<<"success"<<endl;
	}
	return 0;
}

实验题：

题目地址

A

  • 题意：
    由5个烷烃基的原子与化学键的连接方式寻找规律，要求判断输入数据所属的烷烃基的类别。
  • 思路：
    将原子转换为结点，化学键转换为连接两个结点的边，根据输入数据构图。通过统计图中结点的最大度可将烷烃基大致分为4类；然后通过观察2-methylpentane与3-methylpentane的结构看出，图中与最大度结点距离最远的结点到达最大度结点的最短路径为3的是2-methylpentane，为2的是3-methylpentane。故本题的做法总结为：首先计算图中结点的最大度数进行判断，若此时无法得出结论再从图中最大度数结点开始执行一次BFS记录遍历图的最短路径进行比较判断。
  • 代码实现：
#include <iostream>
#include <algorithm>
#include <iostream> 
#include <queue>
#include <cstring>
using namespace std;

int g[10][10];
bool vis[10];
struct node{
	int i;
	int steps;
	node(int ii,int ss){
		i=ii;
		steps=ss;
	}
	node(){
	}
};

int main()
{
	int t,a,b;
	cin>>t;
	while(t--){
		int mp[10];
		memset(mp,0,sizeof(mp));
		memset(g,0,sizeof(g));
		for(int i=0;i<5;i++){
			cin>>a>>b;
			g[a][b]=g[b][a]=1;
			mp[a]++;
			mp[b]++;
		}
		int max=0;
		int id;
		for(int i=1;i<=6;i++){
			if(max<mp[i]){
				max=mp[i];
				id=i;
			}				
		}
		if(max==4)
			cout<<"2,2-dimethylbutane"<<endl;
		else if(max==3){
			bool flag=false;
			for(int i=1;i<=6;i++){
				if(mp[i]==3&&i!=id){
					cout<<"2,3-dimethylbutane"<<endl;
					flag=true;
				}		
			}
			if(!flag){
				queue<node> q;
				q.push(node(id,0));
				memset(vis,0,sizeof(vis));
				vis[id]=1;
				int dis=0;
				while(!q.empty()){
					node t=q.front();
					q.pop();
					for(int i=1;i<=6;i++){
						if(g[t.i][i]!=0&&vis[i]!=1){
							vis[i]=1;
							q.push(node(i,t.steps+1));
							if(t.steps+1>dis)
								dis=t.steps+1;
						}
					}
				}
				if(dis==2)
					cout<<"3-methylpentane"<<endl;
				else
					cout<<"2-methylpentane"<<endl;				
			}
		}
		else
			cout<<"n-hexane"<<endl;
	}
	return 0;
}

B

  • 题意：
    OJ的排名功能实现：给定题数与单位罚时，输入多组学生的数据，按照题目要求进行排名，最后格式化输出排名结果。
  • 思路：
    本题主要考察多关键字结构体排序与格式化输出，首先声明结构体stu，包含姓名、题数、总用时三个属性，并根据题目所给的排序规则重载运算符 < 。由于学生数未知，故将学生结构体数组开大，并在输入过程中用size来记录当前输入数据所对应的索引。对于每次输入的数据利用string类的find函数判断是否存在’('以确定是否存在罚时，利用atoi函数将字符串转换为整数进行计算，最后对结构体数组进行排序并格式化输出结果。
  • 代码实现：
#include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
using namespace std;

struct stu{
	string name;
	int num;
	int time;
	friend bool operator <(stu &s1,stu &s2){
		if(s1.num!=s2.num){
			return s1.num>s2.num;
		}
		else{
			if(s1.time!=s2.time){
				return s1.time<s2.time;
			}
			else
				return s1.name<s2.name;
		}
	} 
}; 

stu Rank[200000];

int main()
{
	int n,m;
	cin>>n>>m;
	string input;
	int i=0;
	int j=0;
	int size=-1;
	string s[20];
	while(cin>>input){
		j=i%(n+1);
		if(j==0)
		 	Rank[++size].name=input;
		else
			s[j]=input;
		string::size_type idx;
		idx=s[j].find('(');
		if(idx!=string::npos){
			string c=s[j];
			string a;
			string b;
			for(int k=0;k<c.size();k++){
				if(c[k]=='('){
					for(int p=k+1;p<c.size()-1;p++)
						a+=c[p];
					break;
				}
				b+=c[k];
			}					
			int err=atoi(a.c_str());
			int ys=atoi(b.c_str());
			Rank[size].num++;
			Rank[size].time+=ys;
			Rank[size].time+=err*m;	
		}
		else{
			int cost=atoi(s[j].c_str());
			if(cost>0){
				Rank[size].num++;
				Rank[size].time+=cost;
			}					
		}
		i++;
	}
	sort(Rank,Rank+size+1);
	for(int i=0;i<=size;i++){ 
		cout<<left<<setw(10)<<Rank[i].name<<" ";
		cout<<right<<setw(2)<<Rank[i].num<<" ";
		cout<<right<<setw(4)<<Rank[i].time;
		cout<<endl;			
	}
	return 0;
}

C

  • 题意：
    指定发牌员，顺时针循环发牌，最后从小到大排序每个人手中的牌，并按照给定格式输出。
  • 思路：
    本题也是多关键字结构体排序问题，首先声明结构体s，为了方便排序，使用char a表示花色，int b表示牌面的值，其中花色按照字典序进行排序（对S与H的比较进行单独处理），牌面的值首先将T、J、Q、K、A分别映射到10、11、12、13、14然后按照整数的升序进行排序。由于每个人的元素是确定的都为13个，故将4个人的数据分段存入一个结构体数组内，然后对每段调用STL的sort函数进行排序，最后格式化输出结果。
  • 代码实现：
#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <cstring>
using namespace std;

struct s{
	char a;
	int b;
	s(){}
	s(char aa,int bb):a(aa),b(bb){}
	friend bool operator<(const s &s1,const s &s2){
		if(s1.a!=s2.a){
			if((s1.a=='S'&&s2.a=='H')||(s1.a=='H'&&s2.a=='S'))
				return s1.a>s2.a;
			else
				return s1.a<s2.a;
		}	
		else
			return s1.b<s2.b;
	}
};

s a[60];
int dindex[10]={0,13,26,39};
map<char,int> mp;
map<int,char> P;
char beginer;

void Output1(int f,int t)
{
	for(int i=f;i<=t;i++){
		if(i==f) 
			cout<<"|";
		if(a[i].b>=10&&a[i].b<=14){
			cout<<P[a[i].b]<<" "<<P[a[i].b]<<"|";
		}
		else
			cout<<a[i].b<<" "<<a[i].b<<"|";
	}		
}

void Output(int f,int t)
{
	cout<<"+---+---+---+---+---+---+---+---+---+---+---+---+---+"<<endl;
	Output1(f,t);
	cout<<endl;
	for(int i=f;i<=t;i++){
		if(i==f)
			cout<<"|";
		cout<<" "<<a[i].a<<" "<<"|";
	}
	cout<<endl;
	Output1(f,t);
	cout<<endl;
	cout<<"+---+---+---+---+---+---+---+---+---+---+---+---+---+"<<endl;
}

int main()
{
	ios::sync_with_stdio(false);
	mp['N']=0;mp['E']=1;mp['S']=2;mp['W']=3;
	mp['T']=10;mp['J']=11;mp['Q']=12;mp['K']=13;mp['A']=14;
	P[10]='T';P[11]='J';P[12]='Q';P[13]='K';P[14]='A';
	while(cin>>beginer){
		if(beginer=='#')
			break;
		int cursor=mp[beginer]+1;
		char input1,input2;
		for(int i=0;i<52;i++){
			cin>>input1>>input2;
			a[dindex[cursor%4]].a=input1;	
			if(input2>='2'&&input2<='9')
				a[dindex[cursor%4]++].b=input2-'0';
			else
				a[dindex[cursor%4]++].b=mp[input2];
			cursor=(cursor+1)%4;
		}	
		sort(a,a+13);
		sort(a+13,a+26);
		sort(a+26,a+39);
		sort(a+39,a+52);
		cout<<"South player:"<<endl;
		Output(26,38);
		cout<<"West player:"<<endl;
		Output(39,51);
		cout<<"North player:"<<endl;
		Output(0,12);
		cout<<"East player:"<<endl;
		Output(13,25);
		cout<<endl;
		dindex[0]=0;dindex[1]=13;dindex[2]=26;dindex[3]=39;
	}
	return 0;
}


总结：

  • 作业：BFS的两道典型例题，其中需要注意的是每次BFS前一定要初始化访问数组和存储路径的数组，对于隐式图问题要先按照题意，将题目条件转换为BFS中的状态信息，尤其需要注意初始结点、目标结点以及搜索时约束条件的确定。
  • 实验：其实三道题目的难度都不大，但是最后结果却全部挂零，主要原因是做题太过浮躁，在以后的做题过程中一定要好好调整心态。A题是图论的简单应用，但由于题目存在多组数据，在每次构图后没有重置邻接矩阵而导致了wa，但课上并未静下心去调试而是转向了B题，在读题时惯性思维，将n（题目数量）当成了学生数量，由于没想到是输入出问题，故一直将重点放在了计算部分和可能导致数组越界的部分，在每层循环输入结束后输出的结果正确但跳出后无输出（当时以为遇到了玄学……），然后就和B题奋战到了下课……(但凡重新读遍题或者在输入那打个断点也不至于这么惨2333)C题同样也是一道结构体排序的题目，但提交后一直re，这个debug的历程更加一言难尽……由于样例输出正确且数据个数为52是固定的，那么按常理来说，结构体数组的索引应该没有问题，然后通过查资料了解到map重载的"[]"运算符使用不当可能会导致Segmentation Fault，故将搜索操作用find函数替代，并在赋值前判断是否已经成功返回正确位置的迭代器，又将插入操作改为insert，然后输出插入结果，发现并未出现问题（what a bad day!），此时心态崩得不行的我随便输入数据进行测试，发现在输入了多组数据后程序崩溃，然后从第3组开始，出现了奇怪的结果，此时突然想到维护结构体数组的索引在每次操作之后没有更新，从而导致了结构体数组的越界，这次实验凉在了初始化上，以后要么用动态数组然后clear要么记住每层循环结束后初始化。


Russellwzr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SDU 程序设计思维与实践 week5 最大矩形【单调栈】
01-08
【SDU程序设计思维与实践】week5的最大矩形问题主要涉及了算法设计中的单调栈这一数据结构。问题的目标是求解给定直方图中最大的矩形面积，直方图由一系列高度不等的小矩形构成，每个小矩形宽度为1。单调栈在这里的...
程序设计思维与实践 Week9 作业 B 东东学打牌
01-06
A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌） ...
程序设计思维与实践 Week2 作业B "倒水问题"
banzixiang的博客
02-29 5254
数据： Sample Input： 2 7 5 2 7 4 Sample Output： fill B pour B A success fill A pour A B fill A pour A B success #include <iostream> #include <queue> #include <stack> using namespace s...
程序设计思维与实践 Week2 作业 B - Pour Wate
cax1165
02-29 251
题目描述： 倒水问题 "fill A" 表示倒满A杯，"empty A"表示倒空A杯，"pour A B" 表示把A的水倒到B杯并且把B杯倒满或A倒空。 Input 输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。 Output 你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个...
程序设计思维与实践 Week2 实验 B 爆零(×)大力出奇迹(√)
cax1165
02-29 213
题目来源： HDU 2093 题目描述： 程序设计思维作业和实验使用的实时评测系统，具有及时获得成绩排名的特点，那它的功能是怎么实现的呢？ 我们千辛万苦怼完了不忍直视的程序并提交以后，评测系统要么返回AC，要么是返回各种其他的错误，不论是怎样的错法，它总会给你记上一笔，表明你曾经在这儿被坑过，而当你历经千辛终将它AC之后，它便会和你算笔总账,表明这题共错误提交了几次。 在岁月的长河中，你通过...
程序设计思维与实践 Week2实验 B - 爆零(×)大力出奇迹(√)
GoodPeople233的博客
03-05 177
程序设计思维作业和实验使用的实时评测系统，具有及时获得成绩排名的特点，那它的功能是怎么实现的呢？ 我们千辛万苦怼完了不忍直视的程序并提交以后，评测系统要么返回AC，要么是返回各种其他的错误，不论是怎样的错法，它总会给你记上一笔，表明你曾经在这儿被坑过，而当你历经千辛终将它AC之后，它便会和你算笔总账,表明这题共错误提交了几次。 在岁月的长河中，你通过的题数虽然越来越多，但通过每题时你所共花去的时间...
程序设计思维与实践 Week2 作业
qq_44157558的博客
03-04 164
A-Maze 东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。 Input 　　输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。 Output 　　输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样...
山东大学MATLAB应用教程 第4讲 MATLAB程序设计（共60页）.ppt
11-02
山东大学MATLAB应用教程 第1讲 MATLAB程序设计基础（共26页）.ppt 山东大学MATLAB应用教程 第2讲 MATLAB的数值计算（共65页）.ppt 山东大学MATLAB应用教程 第3讲 MATLAB的图形功能（共62页）.ppt 山东大学MATLAB应用...
week5-prototype:第五周PCG游戏设计游戏2021
03-09
在本周的主题"week5-prototype:第五周PCG游戏设计游戏2021"中，我们聚焦于使用JavaScript进行程序化内容生成（Procedural Content Generation, PCG）以设计游戏。PCG是一种创新的游戏开发技术，它允许游戏世界、关卡...
C语言程序设计报告—“万年历”
06-30
在本报告中，我们将深入探讨如何使用C语言设计并实现一个“万年历”程序，该程序能够...这个“万年历”程序设计报告展示了C语言在解决实际问题中的应用，同时也揭示了编程过程中分析问题、设计算法和编写代码的重要性。
程序设计思维与实践 Week2 作业 A - Maze
cax1165
02-29 261
题目描述： 　东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图 Input 输入是一个5× 5的二维数组，仅由0、1两数字组成，表示法阵地图。，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。 Output 　输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式...
程序设计思维与实践 Week2 作业&实验
但行好事，莫问前程.
03-03 256
A - Maze 东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。 Input 　　输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。 Output 　　输出若干行，表示从左上角到右下角的最短路径依次经过的...
程序设计思维与实践 Week2 实验 A 化学
cax1165
02-29 241
题目来源： Gym 270437A 题目描述： 化学很神奇，以下是烷烃基。 假设如上图，这个烷烃基有6个原子和5个化学键，6个原子分别标号1~6，然后用一对数字 a,b 表示原子a和原子b间有一个化学键。这样通过5行a,b可以描述一个烷烃基 你的任务是甄别烷烃基的类别。 原子没有编号方法，比如 1 2 2 3 3 4 4 5 5 6 和 1 3 2 3 2 4 4 5 5 6...
程序设计思维与实践 Week2 实验 C 瑞神打牌
cax1165
02-29 241
题目来源： POJ 1786 题目描述： 瑞神HRZ因为疫情在家闲得无聊，同时他又非常厉害，所有的课对他来说都是水一水就能拿A+，所以他无聊，找来了另外三个人：咕咕东，腾神以及zjm来打牌（天下苦瑞神久矣）。 显然，牌局由四个人构成，围成一圈。我们称四个方向为北 东 南 西。对应的英文是North，East，South，West。游戏一共由一副扑克，也就是52张构成。开始，我们指定一位发牌员...
程序设计思维与实践week2 作业一
qq_43822464的博客
03-01 181
一.1:maze 关于地图的最短路径问题 （1):问题描述： 本题输入数据为一个5*5的地图，问题是求得左上角(0,0)到右下角(5,5)的最短路径，并输出途径的地图网格，其中输入数据中0代表可以走,1代表不可以走。 （2）：思路 这道题很明显可以用bfs进行解题，为了解题的简单我为地图新增了墙壁，就是在地图最外围新增一圈(1,1)；也为了输出的简便，我们从终点开始向起点进行反向遍历，这样结果输...
程序设计思维与实践 Week2 作业A 迷宫问题
banzixiang的博客
02-29 250
数据： Sample Input： 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 Sample Output (0, 0) (1, 0) (2, 0) (3, 0) (3, 1) (3, 2) (2, 2) (1, 2) (0, 2) (0, 3) (0, 4) (1, 4) (2, 4) (3, 4) (4, 4) #include &l...
【20200228程序设计思维与实践 Week2 实验】A-化学
Camlost的博客
03-02 212
题意： 化学很神奇，以下是烷烃基。 假设如上图，这个烷烃基有6个原子和5个化学键，6个原子分别标号1~6，然后用一对数字 a,b 表示原子a和原子b间有一个化学键。这样通过5行a,b可以描述一个烷烃基 你的任务是甄别烷烃基的类别。 原子没有编号方法，比如 1 2 2 3 3 4 4 5 5 6 和 1 3 2 3 2 4 4 5 5 6 是同一种，本质上就是一条链，编号其实是没有关系的，可以在纸上...
B - Pour Water倒水问题
chihiro的博客
03-01 3632
题目： 倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。 Input： 输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。Output你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单...
OpenGL3.3_C++_Windows(32)
最新发布
sengyongan的博客
07-29 409
demo SSAO SSAO 环境光照(Ambient Lighting)：光的散射，我们通过一个固定的常量作为环境光的模拟， 但是这种固定的环境光并不能很好模拟散射，因为环境光不是一成不变的， 环境光遮蔽：让（褶皱、孔洞）等变暗的方法近似模拟出间接光照，但是这一技术会带来很大的性能开销，因为它还需要考虑周围的几何体。 屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO)：这一技术使用了屏幕空间场景的深度而不是真实的几何体数据来确定遮蔽量。 原理：对
event.table.partition.history.week=-2
07-13
'event.table.partition.history.week=-2'是一个配置属性，用于指定事件表分区历史的时间范围。在这个例子中，属性的值为-2，表示事件表分区历史的时间范围为两周之前。 这个属性可能与事件表分区策略相关，用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值