近期科班实验课&PAT总结

已于 2022-07-21 01:30:46 修改
阅读量272 收藏
点赞数
文章标签： leetcode 数据结构 算法
于 2022-06-09 15:42:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amzirl/article/details/125201538
版权

一、近两周的数据结构实验课：

①第15周数据结构实验课：

1、出栈序列合法性&栈的最小容量：

给定入栈序列，判定出栈序列的合法性&给定入栈与出栈序列判定栈的最小容量——解题思路：建立一个队列来保存入栈序列，建立一个队列保存出栈序列，建立一个空栈用作临时栈。

当然了，建立数组存储序列也可以，实际上操作还是和队列差不多的。

然后就是一个循环——每次从入栈序列队列取出元素入栈后，比较栈顶元素和出栈序列队列队头元素，如果相等，弹栈+出队。循环的跳出条件为任一队列为空，然后在循环跳出后判定临时栈是否为空。如果栈不为空，说明出栈序列不合法。

相对应的，对于栈最小容量的求解，只需要增加一个变量，每次有元素入栈之后都判定一下当前栈的容量和变量保存的容量的大小，如果当前大，则更新该变量，最后输出即可。

代码实现：

 2、递归枚举所有的字母排列数：（输入的数字n代表需要枚举前n个字母）

#include<vector>
#include<iostream>
using std::cin;
using std::vector;
using std::cout;
char char_list[] = { 'a','b','c','d','e','f','g' };
bool visited[7] = { 0 };
//参数分别为：还需要枚举多少次字符,一次需要枚举多少个字符
vector<char>ans;
int index = 0;
void DFS(int n,int nums)
{
	if (n == 0)
	{
		for (auto i : ans)
			cout << i;
		cout << "\n";
		return;
	}
	for (int i = 0; i < nums; i++)
	{
		ans.push_back(char_list[i]);
		DFS(n - 1, nums);
		ans.pop_back();
	}
}
int main()
{
	int n;
    cin >> n;
	DFS(n, n);
}

如果需要祛重的话：

		if (!visited[i])
		{
			//如果没访问过，则设为已访问，再接着这个点继续访问
			visited[i] = 1;
			ans.push_back(char_list[i]);
			DFS(n - 1, nums);
			ans.pop_back();
			visited[i] = 0;
		}

总之，重点从递过去的过程，以及归回来的过程（比如回溯过程的清除访问标记&数列pop）这两个过程来理解整个题目！

//扒答案之后得到的另一种解法：

用字符串处理，本质上也是和vector的处理思路类同。祛重也是同样的操作：

②第16周数据结构实验课：

1、接收层序遍历方式（上->下，左->右）的输入来构造树：

思路——按照层序遍历输出的模式来接受输入：

counts代表的是后续会输入的一个变量，它的值代表着将要输入的顶点数

int index = 0;
int counts;
void createTree()
{
	if (!counts)
		return;
	queue<TreeNode*>Q;
	char value;
	cin >> value;
	root = new TreeNode(value);
	Q.push(root);
	index++;
	while (!Q.empty())
	{
		TreeNode*temp=Q.front();
		Q.pop();
		if (index >= counts)
			break;
		cin >> value;
		temp->left = new TreeNode(value);
		index++;
		Q.push(temp->left);
		if (index >= counts)
			break;
		cin >> value;
		temp->right = new TreeNode(value);
		index++;
		Q.push(temp->right);
	}
}

使用队列来保证这样的先后顺序---这就是BFS的思想，这一层的结点出队的同时，下一层对应的结点入队。画画这个队列的出入过程即可理解这个循环的操作！

2、关于递归的查错方式：

能不通过断点就不通过断点，最好是通过递归出口，加上模拟递过程&归过程（回溯过程很重要！！！）来思考递归书写上的问题（有时候还会抄错函数名，比如把inorder复制到postorder里面然后忘记改名）。如果实在要打断点来看，一定要尽可能的去看递归深度小的递归过程，比较好理解。

3、当采取下标的形式时，要注意转换思路，从传参为纯指针变为下标相关的参量：

#include<iostream>
#include<unordered_set>
using std::cin;
using std::cout;
using std::unordered_set;
struct TreeNode
{
	int lowcast;
	int left;
	int right;
};
TreeNode* ans;

void postorderTraverse(TreeNode root)
{
	if (root.lowcast == -1||root.lowcast==0)
		return;
	postorderTraverse(ans[root.left]);
	postorderTraverse(ans[root.right]);
	cout << root.lowcast << " ";
}
void preorderTraverse(TreeNode root)
{
	if (root.lowcast == -1 || root.lowcast == 0)
		return;
	cout << root.lowcast << " ";
	preorderTraverse(ans[root.left]);
	preorderTraverse(ans[root.right]);
}
void inorderTraverse(TreeNode root)
{
	if (root.lowcast == -1 || root.lowcast == 0)
		return;
	inorderTraverse(ans[root.left]);
	cout << root.lowcast << " ";
	inorderTraverse(ans[root.right]);
}
int main()
{
	int N;
	cin >> N;
	ans = new TreeNode [N + 1];
	for (int i = 1; i < N+1; i++)
	{
		int M;
		cin >> M;
		ans[M].lowcast = M;
		cin >> ans[M].left;
		cin >> ans[M].right;
	}
	//找根：
	unordered_set<int>assist;
	for (int i = 1; i < N+1; i++)
	{
		assist.emplace(ans[i].left);
		assist.emplace(ans[i].right);
	}
	int get_lowcast;
	for (int i = 1; i < N + 1; i++)
	{
		if (assist.find(ans[i].lowcast)==assist.end())
		{
			get_lowcast = i;
			break;
		}
	}
	inorderTraverse(ans[get_lowcast]);
}

※虽然但是，接收层序遍历的输入，明显可以用数组存储，再用数组作遍历操作：

所以第一个题的代码可以改成：

4、关于满二叉树的层高的问题——

※输入的所有的结点，都是幌子。只需要根据完全二叉树的性质来看即可：

③第17周数据结构实验课：

1.任意二叉树的层序遍历：

重点在于数组下标和顶点编号的一一对应（看清楚编号从0开始还是1开始！），采用结构体的方式来存储左右孩子的下标&自己的下标(val)

一一对应的时候，记得首先要对自己的下标进行初始化，同时根据题目的编号规则来决定从1开始还是从0开始

寻求根节点的菜逼解法：

发答案之后康康老师的优化解法！

紧接着就是基于队列实现的层序遍历解法——

2.小根堆的判定——不同于小根堆的生成，判定的话只需要递过程就可以结束（看看当前节点是不是比它俩孩子都小就够了）。而仅存在递过程时，往往只需要循环就可以解决。仅存在归过程的时候，或许仍然需要递归的方式来看

红框是由于下标从0开始才做了这样的(i+1)*2-1的操作，而下标从1开始的话，只需要简单粗暴的i*2&i*2+1即可。由此在这种数组存储的完全二叉树中，直接从下标为1的位置开始存储即可，免得不必要的麻烦。

3.最小堆的生成：（看标准答案&扒一扒AVL与红黑的修正思路！）

蠢逼解法：由于递过程和归过程都需要判断&修正，因此递归体的结构应当是：

递过程对当前节点的处理

递归调用函数

归过程的处理

于是：

void change_to_min(int lowcast)
{
	if (lowcast > n)
		return;
	int index = 0;//0不换，1和左边换，2和右边换
	int min=ans[lowcast];
	if (lowcast * 2 <= n)
	{
		if (ans[lowcast * 2] < min)
		{
			min = ans[lowcast * 2];
			index = 1;
		}
	}
	if (lowcast * 2 + 1 <= n)
	{
		if (ans[lowcast * 2 + 1] <min)
		{
			min = ans[lowcast * 2 + 1];
			index = 2;
		}
	}
	if (!index)
		return;
	if (index == 1)
	{
		ans[lowcast * 2] = ans[lowcast];
		ans[lowcast] = min;
	}
	else
	{
		ans[lowcast * 2 + 1] = ans[lowcast];
		ans[lowcast] = min;
	}	
	//不需满足左小右大之类的左右顺序规则
	//只是和min做交换即可

	change_to_min(lowcast * 2);
	change_to_min(lowcast * 2 + 1);


	int index_back = 0;//0不换，1和左边换，2和右边换
	int min_back = ans[lowcast];
	//这样可能会使得左右孩子的次序颠倒,如果是先左再右这样来判别
	if (lowcast * 2 <= n)
	{
		if (ans[lowcast * 2] < min_back)
		{
			min_back = ans[lowcast * 2];
			index_back = 1;
		}
	}
	if (lowcast * 2 + 1 <= n)
	{
		if (ans[lowcast * 2 + 1] < min_back)
		{
			min_back = ans[lowcast * 2 + 1];
			index_back = 2;
		}
	}
	if (!index_back)
		return;
	if (index_back == 1)
	{
		ans[lowcast * 2] = ans[lowcast];
		ans[lowcast] = min_back;
	}
	else
	{
		ans[lowcast * 2 + 1] = ans[lowcast];
		ans[lowcast] = min_back;
	}
}

上下两部分做的工作完全相同，只是改了些变量的名字避免重定义问题而已。

标准code：在插入过程中即不断地进行回溯更新


#include<iostream>
using namespace std;
int h[50];
int n = 10;
void sifup(int i)
{
    if (i == 1)
    {
        return;
    }
    while (i / 2 != 0)
    {
        if (h[i] < h[i / 2])
        {
            swap(h[i], h[i / 2]);
        }
        else
        {
        //此时说明插入的结点已经到了正确的位置，return即可
            return;
        }
        i = i / 2;
    }
}
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> h[i];
        sifup(i);
    }
    for (int i = 1; i <= n; i++)
    {
        cout << h[i] << " ";
    }
    cout << endl;
    return 0;
}

4.无向图的深搜：

深搜的条件是以编号小的结点先开始搜，于是递归时只需要先对当前结点的相邻结点作编号大小的排序，然后再跑一个循环分别搜即可

这个edges，实际上就是“遇事不决加变量”的思想的体现，在对结点的初始化的过程中，顺便存储好这个结点对应的边数即可。方便后续排序的时候知道上界。

（注意加visited数组！！！而且一定要初始化！！！！）

还有的，非常重要的一点——无向图一定要做好对称化处理！输入阶段就可以完成处理：

标准code：直接使用下标进行一一对应，而不去记录各种结点的信息！！！

#include<iostream>
using namespace std;
bool visited[100];
typedef struct
{
    int arc[100][100];
    int numnodes,numedges;
}mgraph;
void DFS(mgraph &g,int i)
{
    int j;
    visited[i]=true;
    cout<<i<<" ";
    for(j=0;j<g.numnodes;j++)
    {
        if(g.arc[i][j]==1&&!visited[j])
        {
            DFS(g,j);
        }
    }
}
int main()
{
    mgraph g;
    int i,j,k,w;
    cin>>g.numnodes>>g.numedges;
    for(i=0;i<g.numnodes;i++)
    {
        for(j=0;j<g.numnodes;j++)
        {
            g.arc[i][j]=0;
        }
    }
    for(k=0;k<g.numedges;k++)
    {
        cin>>i>>j;
        g.arc[i][j]=1;
        g.arc[j][i]=1;
    }
    DFS(g,0);
    return 0;
}

5.无向图的广搜：

要求遵循小顶点优先的原则，同样的，先排序，入队的时候小的优先入队即可。大致的输入的接受&结点结构和深搜类似（标准code也是！一定要记得还有下标一一对应这种写法！！）

6.最小生成树：跑Prim即可，比Kruskal好写点，不用维护并查集数组

这个题目只是需要最终的最小权值，所以：

※注意循环是循环vernum次还是vernum-1次——一般是vernum-1次，因为先从0开始，0就直接加入了，然后再处理vernum-1个顶点即可

以及：非常重要的对陈化处理：

④第18周数据结构实验课整理：

1、二分查找——注意一点，有序序列不代表就是一定是升序！虽然样例给的是升序，但不要被迷惑

 ※蠢逼写法：写两个名字不同的函数

留尾巴——如何利用多态性&函数指针之类的思想来完成复用？？


#include<iostream>
using namespace std;
int arr[1000];
int N;
int x = 1;
bool BinarySearch_down(int a)
{

	int low = 0, high = N - 1;
	while (low <= high)
	{
		int mid = (low + high) / 2;
		if (arr[mid] == a)
			return true;
		if (arr[mid] < a)
		{
			x++;
			high = mid - 1;
			continue;
		}
		if (arr[mid] > a)
		{
			x++;
			low = mid + 1;
			continue;
		}

	}
	return false;
}
bool BinarySearch_up(int a)
{
	int low = 0, high = N - 1;
	while (low <= high)
	{
		int mid = (low + high) / 2;
		if (arr[mid] == a)
			return true;
		if (arr[mid] > a)
		{
			x++;
			high = mid - 1;
			continue;
		}
		if (arr[mid] < a)
		{
			x++;
			low = mid + 1;
			continue;
		}

	}
	return false;
}
int main()
{
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i];
	}
	int a;
	cin >> a;
	if (N == 1 && a == arr[0])
	{
		cout << "1" << endl;
		return 0;
	}
	if (arr[1] > arr[0])
	{
		bool m = BinarySearch_up(a);
		if (!m)
		{
			cout << "NO" << endl;
			return 0;
		}
		cout << x;
	}
	else
	{
		bool m = BinarySearch_down(a);
		if (!m)
		{
			cout << "NO" << endl;
			return 0;
		}
		cout << x;
	}
}

2、二叉排序树的构建——不要忘记插入的时候通过temp&pre的前后指针来找插入位置的思想

严格卡好左小右大！构建完之后跑一下中序遍历看看是否严格升序，很可能会写的时候写反左右——同时，不要写顺手写成while(!root_node)

#include<iostream>
using namespace std;
struct TreeNode
{
	int val;
	TreeNode* right;
	TreeNode* left;
	TreeNode() :val(0),  right(0), left(0) {}
	TreeNode(int a) :val(a), right(0), left(0) {}
};
TreeNode* root;
void insert(TreeNode* root_node, int val)
{
	TreeNode* temp = root_node;
	while (root_node)
	{
		temp = root_node;
		if (val > root_node->val)
		{
			root_node = root_node->right;
			continue;
		}
		root_node = root_node->left;
	}
	//往temp右边插入
	if (val > temp->val)
	{
		temp->right = new TreeNode(val);
		return;
	}
	temp->left = new TreeNode(val);
}
int x=0;
bool BSTSearch(TreeNode*root_node,int val)
{
	while (root_node)
	{
		x++;
		if (val > root_node->val)
		{
			root_node = root_node->right;
			continue;
		}
		if (val < root_node->val)
		{
			root_node = root_node->left;
			continue;
		}
		return true;
	}
	return false;
}
int main()
{
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	int N;
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		int a;
		cin >> a;
		if (!i)
		{
			root = new TreeNode(a);
			continue;
		}
		insert(root, a);
	}
	int T;
	cin >> T;
	bool a = BSTSearch(root, T);
	if (!a)
	{
		cout << "NO" << endl;
		return 0;
	}
	cout << x << endl;
}

3&4、迪杰斯特拉——第四题的获取路径的方法扒一下答案看看除了从终点起入栈直到源点，再出栈得到路径这样做以外的别的处理方式

看清楚是有向图还是无向图！！！！！！！！！！！！！！

Path[i] = origin-'A';
		//默认就是从origin中转，Path不要默认写作-1，而应当初始化为源点！
        //尤其是单源点到单终点的问题，常常会循环跑不全最后导致某个点path仍-1导致路径输出异常

//迪杰斯特拉的二叉堆形式优化写法：

//过程即是把所有的和源点相关的顶点入队

//取出堆顶元素,更新相邻顶点的minimum path值

不过这样的话，堆顶元素存的就得是个Node，因为要记录最短路径值&自己的下标来更新相邻顶点

5、读入病人ID————注意不要用整型数来存储ID，会自动舍弃高位的0（毕竟他是个数学意义上的数字，存储高位0本身没有任何意义）。

二、2022夏季PAT甲级考试整理：

①经验：别死磕，读好题再开敲，带好笔和纸画好图，多玩限时训练来适应这种模式。

②题目整理：

1、无聊的猜天数问题，但是要注意，一定别忘了“循环”问题，也就是周一的上一天是周日，周日下一天是周六，这个很容易被忽略导致少过样例。但是，即使有样例没过，也千万不要在一道题死磕，没有任何意义！

补充一点，循环问题，有一个很重要的处理方式，也就是取余。

可以在作差之后+7，再拿整体和7取余！

菜逼专属暴力枚举写法：

#include<iostream>
using namespace std;
int a[3], b[3];
string ToString(int a)
{
	switch (a)
	{
	case -1:return "Saturday";
	case 0: return "Sunday";
	case 1: return "Monday";
	case 2: return "Tuesday";
	case 3: return "Wednesday";
	case 4: return "Thursday";
	case 5: return "Friday";
	case 6: return "Saturday";
	case 7: return "Sunday";
	}
	return "";
}
int main()
{
	for (int i = 0; i < 3; i++)
	{
		cin >> a[i];
	}
	for (int i = 0; i < 3; i++)
	{
		cin >> b[i];
	}
	//如果a[0]对
	if (a[0] == b[0])
	{
		cout << ToString(a[0] + 1) << endl;
		cout << "yesterday" << endl << "yesterday";
		return 0;
	}
	//这个代表着  a的昨天与b的今天相等
	//如果a的昨天是周六
	if (a[0] == b[1] - 1||a[0]==6&&b[1]==0)
		{
			cout << ToString(a[0] + 1) << endl;
			cout << "yesterday" << endl << "today";
			return 0;
		}
		if (a[0] == b[2] - 2)
		{
			cout << ToString(a[0] + 1) << endl;
			cout << "yesterday" << endl << "tomorrow";
			return 0;
		}
	
		

		if (a[1] == b[0]+1||a[1]==0&&b[0]==6)
		{
			cout << ToString(a[1]) << endl;
			cout << "today" << endl << "yesterday";
			return 0;
		}
		if (a[1] == b[1])
		{
			cout << ToString(a[1]) << endl;
			cout << "today" << endl << "today"; 
			return 0;
		}
		if (a[1] == b[2] - 1 || a[1] == 6 && b[2] == 0)
		{
			cout << ToString(a[1]) << endl;
			cout << "today" << endl << "tomorrow";
			return 0;
		}
		

		if (a[2] == b[0]+2||a[2]==0&&b[0]==5&&a[2]==1&&b[0]==6)
		{
			cout << ToString(a[2]-1) << endl;
			cout << "tomorrow" << endl << "yesterday";
			return 0;
		}
		if (a[2] == b[1] + 1 || a[2] == 0 && b[1] == 6)
		{
			cout << ToString(a[2]-1) << endl;
			cout << "tomorrow" << endl << "today";
			return 0;
		}
		if (a[2] == b[2])
		{
			cout << ToString(a[2]-1) << endl;
			cout << "tomorrow" << endl << "tomorrow";
			return 0;
		}
		return 0;
}

2.二叉堆的类似实现：

补充内容：（1）一个提高读取文件的速度的小妙招：

 一定要注意这两个加速方式的使用！！！！

（2）：set与map的使用区别：

对于此题目的书写：

重点在于对于堆中元素存在性的查找，以及对于堆中元素的更新。这也是引起超时的一大原因。

而且注意频繁使用的操作，要封装成inline的形式，尽可能的优化速度！

※重写之后的代码：

3、DFS的正确性检查：

三、PAT甲级相关练习题目整理

RealJerome
关注
PAT-实验4-2-5 水仙花数 (20分)
EchoChao的博客
10-12 690
小白专用哦，毕竟我也是小白，自己也没有用到函数定义，虽然麻烦了一点，但小白啊！！！ 实验4-2-5 水仙花数 (20分) 水仙花数是指一个N位正整数（N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=1^3 + 5^3 +3^3​ 。 本题要求编写程序,计算所有N位水仙花数。 输入格式: 输入在一行中给出一个正整数N（3≤N≤7）。 输出格式: 按递增顺序输出所有N位水仙花数，每个数字占一行。 输入样例:3 输出样例: 153 370 371 407 本代码没有用到函数定义，适合像我一样的新
实验心得
热门推荐
xy123456789123的博客
06-21 1万+
实验心得一．拓扑设计： 二．方案设计(1) FTP，PAT，DHCP，VTP，LACP，HSRP等命令配置一个校内网。(2) 掌握局域网与互连网的连接技术。(3) 掌握访问控制规则的设置方法。(4) 实施思路：   1.提出技术方案，结合实验环境设计网络拓扑。在校园大网关上配置NAT。在FTP服务器接口设置访问控制规则。2.设备配置校园大网关：配置静态NAT，动态NAT或NAPT。内网交换机：创建...
pat总结（1）
qq_33666011的博客
09-07 301
1、Count PAT's (25) 题目：给一段由PAT三个字母组成的字符串，看里面能组成几个Pat。 #include <iostream> #include <stdio.h> #include <vector> using namespace std; int coun(string a) { int pnum=0;//pnum存的是p有...
静态PAT、动态PAT实验报告
weixin_34050427的博客
11-27 1823
网络运维 静态PAT、动态PAT 实验报告 姓名： 李军 班级： NTD1710 日期：2017年 1 月 5 日 实验任务 配置要求： PC192.168.1.1通过防火墙动态PAT转换访问PC120.1.1.1 Server通过防火墙静态PAT转换访问PC120.1.1.1 思路及实验步骤 配置思路： 第一步、首先配置终端设备PC机和Se...
OSPF&PAT综合实验报告
weixin_33754065的博客
12-21 306
1.1 实验任务 按照拓扑图配置OSPF区域、外部路由和网络地址转换 1.2 实验环境和网络拓扑 IP地址规划 路由器 接口 IP地址 Loopback 0 R1 F0/0 192.168.10.1/24 1.1.1.1 R2 F0/0 192.168.1...
计算机科班数据结构实验报告
最新发布
06-16
在本篇“计算机科班数据结构实验报告”中，实验着重于顺序表这一基础且重要的数据结构，主要涉及以下几个方面的知识： 1. **顺序表**：顺序表是一种线性表，其中元素按照它们在内存中的物理顺序存储。这种结构的...
计科班(软工)-实验111
08-03
【标题】：“计科班(软工)-实验111” 实验主要涉及的知识点是“链表”和“树的螺旋遍历”。 【描述】：“计科班(软工)-实验111” 实验任务是使用孩子兄弟链表（也称为孩子-兄弟表示法）来构建一棵有序树，并按照...
计科班(软工)-实验51
08-03
实验51是一个针对计算机科学与技术专业（计科班）软件工程方向的学生设计的数据结构上机练习，主要涉及线性表这一基本数据结构的操作。线性表是数据结构中的基础概念，它是一组有序的数据元素集合，可以是顺序存储或...
计科班(软工)-实验101
08-03
在本次实验“计科班(软工)-实验101”中，我们有两个主要任务，涉及链表以及二叉链表的应用。 首先，我们要解决的是判断一个字符串是否为英语回文的问题。这里的关键是理解回文的概念，即一个字符串无论从前往后读...
计科班(软工)-实验71
08-03
【实验71】主要涉及了计算机科学中的一些基础算法和数据结构问题，下面将逐一解析这些知识点。 **1. 求一元 n 次多项式 Pn(x)的导函数** 这个问题涉及到数学和编程的结合。在数学中，一元n次多项式的导函数可以通过...
Algorithm:个人刷题记录，译文来自蓝桥杯，PAT，力扣
03-29
观看介绍 此仓库主要记录自己刷题过程中的部分代码，陆续会更新PAT译文，蓝桥杯题库和Letcode，但毕竟初学者并没有大佬的能力和力量，PAT建议看柳神，Letcode建议看路西法，这都是真正的算法大牛 建立此仓库的目的主要是记录和总结（毕竟辛辛苦苦写的代码也不忍心写完就放硬盘里积灰），顺便以后让面试官看看咱也不是个懒人，只要还在写代码，就应该会一直更新吧 3/17/21首次更新 只更新了PAT甲级题，部分解题代码全上传上来了在答案文件夹下，译文在浙大PAT练习网站中都有，但记笔记的时候还是都被捏了下来，所以和思路也一并放在一个另一个文件夹中，解题笔记按分类写的，但也是只有一部分，来日放长吧。。。 3/21/21更新~~ 将当前写过的所有指南笔记PO了上来，本来想建一个GitHub Pages专门写了一个指南博客，但后来又觉得没有必要，网上已经有很多类似的贴子了，再写的作用也不过是给自己看
pat-and-leetcode:IT界的托福（尴尬）和LeetCode相关的自己写的垃圾代码
03-16
算法题 记录一些自己的数据结构与算法题时写的垃圾代码，主要有PAT和LeetCode PAT参加了2021年Spring的考试，结果不是很理想，准备了三个礼拜结果有道题考场上没做出来，感觉是刷题浮于表面，考场上心态不好的缘故，没办法只能9月份的时候再考一次秋季的PAT了，给cy送钱真开心，我就是cy的小财布这件事对我的打击比较大，导致我一整天萎靡不振，我觉得真的很丢脸 LeetCode之前刷的比较混乱和随意，什么语言什么类型的翻译都有，后面应该持续更新
刷pat和leetcode-PAT-Leetcode:浙大PAT&Leetcode刷题笔记
07-07
刷pat和leetcode 起始 因为最近疯狂种草胶片相机，但想要作为奖励送给自己而不是冲动消费 （一般我会在...第二周丧失热情） 同时又希望在PAT和Leetcode刷题以及玩Human Resource Machine这件事不要三分钟热度。 所以我给自己定了计划:刷完100个Leetcode和浙大PAT乙级题库之后就去收割我的相机！ 做此项目记录刷题笔记及心得，祝我好运。 内容 应该包括 刷Leetcode时我有多蠢（刷题笔记） 看工具书的时候我有多蠢（读书笔记） 刷PAT时我有多蠢（刷题笔记） 刷题提交记录 欢迎 希望有和我一样拖延症和三分钟热度的朋友一起记录打败拖延症走向人生巅峰的process （btw等我工作了再用GitHub一定会觉得这个是黑历史的，但whatever现在的我是在解决自己的问题而不是得过且过啊
2021秋季pat总结
qq_42877165的博客
09-11 232
2021秋季pat 这次的考试比较简单，一小时二十分钟左右做完了，感觉有点拉不开差距。。。 第一题 #include<bits/stdc++.h> using namespace std; struct Node{ int first,l; }node[10005]; int main(){ //假如i大于l0 int n,m; cin>>n>>m; for(int i=0;i<n;++i){ cin>&
PAT个人总结【01】
weixin_43027217的博客
02-17 137
C语言中使用scanf函数的读取注意事项 1. 若非%c,则存在两点： 读取时遇到**空格/换行/制表符等跳过空格/换行/制表符等**，读取后续数据 读取以**空格/换行/制表符等**为结束标准 2. 若为%c时 将会读取**空格/换行/制表符等**（转义字符&空格也是字符嘛） ...
PAT配置心得（GNS3）
pointer_NULL的博客
02-21 726
一、为了干啥？ 1.在同一网段可以直接通信，但如何在不同网段通信？对，没错就是利用NAT技术，但需要用内网地址 1:1 映射在外网的地址，就照成了浪费。 2.多个内网地址映射在外网的同一个地址上，需要表明端口号，端口号有多个，也就是可以映射多少（65536）个 二、PAT技术 （1）如上图，192.168.0.0 要访问100.1.0.0，就需要如下配置 1.shouxian1 R1配置：进入全局模式配置f0/0的地址 int f0/0 no shutdown ip address
PAT甲级目录&刷题记录
发现问题，并解决问题，批判性思维
02-22 1739
编号 标题 题解 分类 备注 1001 A+B Format C++ 字符串处理 1002 A+B for Polynomials C++ 中级模拟+散列 多项式求和问题 1003 Emergency C++ 图 最短路径问题 1004 Counting Leaves C...
力扣&PAT刷题总结（一）
amzirl的博客
07-27 562
题目整理&延拓
力扣&PAT刷题总结（二）
amzirl的博客
08-21 594
整理
python后端开发需要什么基础科班知识
05-27
Python后端开发需要一些基础的科班知识，以下是一些比较重要的基础科班知识： 1. 计算机网络：了解计算机网络基础知识，如TCP/IP协议、HTTP协议、DNS解析、网络安全等。 2. 数据库：了解数据库基础知识，如关系型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值