PAT第八章专题复习

PAT第八章专题复习

• 本章的算法笔记上的题目已做，蓝桥杯题目大致看了一下。

• dfs题

  • 题目描述【PAT A 1103】，分解因子

    • 思路：

      ①用dfs做思路是清晰的，不过自己在写dfs时超时了。在选择最优解时，时间复杂度不是O(1),导致超时。

      ②如果使用原先的递归式，将不能够保证存储到temp中的数是从大到小排序的，如果需要从大到小排序，就必须事先将数存储起来，然后dfs的时候直接调用，类似dfs时调用的是数组下标，而不是数组值本身。

      ③看了题解，发现可以事先将因子存储起来，然后dfs求最优解时就不必因为字典序的大小而进行排序操作，大大减少了时间复杂度。

    • 代码实现

      #include<bits/stdc++.h>
      using namespace std; 
      int n, k, p, ansSum = 0, st;
      vector<int> temp, ans, fac;
      void dfs(int index, int sumP, int sum, int num){
      	//递归边界
      	if(num == k && sumP == n){
      		if(ansSum < sum){
      			ansSum = sum;
      			ans = temp;
      		}
      		return;
      	} 
      	if(num >= k || sumP > n)return;
      	//递归式，原先思路，将不能保证从大到小排序
      //	for(int i = st; i >= 1; i--){
      //		temp.push_back(i);
      //		dfs(index+1, sumP + pow(i, p), sum + i);
      //		temp.pop_back();
      //	} 
      	//递归式
      	if(index >= 1){
      		temp.push_back(index);
      		dfs(index, sumP + fac[index], sum + index, num+1);
      		temp.pop_back();
      		dfs(index-1, sumP, sum, num);
      	}
      	
      }
      int main(){
      	cin >> n >> k >> p;
      	for(int i = n; i >= 1; i--){
      		if(pow(i, p) <= n - k + 1){
      			st = i;
      			break;
      		}
      	}
          //事先将因子的p次方存储到fac当中，降低时间复杂度
      	fac.push_back(0);
      	for(int i = 1; i <= st; i++){
      		fac.push_back(pow(i, p));
      	}
      	dfs(st , 0, 0, 0);
      	if(ans.size() != 0){
      		printf("%d = %d^%d", n, ans[0], p);
      		for(int i = 1; i < ans.size(); i++){
      			printf(" + %d^%d", ans[i], p);
      		}
      	}else printf("Impossible");
      	return 0;
      }
      

• bfs题

  • 题目描述【PAT A 1091】三维地图

    • 思路：

      ①按照bfs遍历二维数组的思路，类推到遍历三维数组。

    • 代码实现

      #include<bits/stdc++.h>
      using namespace std; 
      int m, n, L, T, sum = 0, cnt = 0;
      int mp[1300][130][65], vis[1300][130][65] = {0};
      //三维方向数组写法值得学习
      int dx[6] = {0, 0, 1, -1, 0, 0};
      int dy[6] = {0, 0, 0, 0, 1, -1};
      int dz[6] = {1, -1, 0, 0, 0, 0};
      struct node{
      	int x, y, z;
      	node(int x1, int y1, int z1):x(x1), y(y1), z(z1){
      	}
      };
      bool judge(int x, int y, int z){
      	if(x >= m || x < 0 || y >= n || y < 0 || z >= L || z < 0){
      		return false;
      	}
      	if(mp[x][y][z] == 0 || vis[x][y][z] == 1)return false;
      	return true;
      }
      void bfs(int x, int y, int z){
      	queue<node> q;
      	q.push(node(x, y, z));
      	vis[x][y][z] = 1;
      	while(!q.empty()){
      		node now = q.front();
      		q.pop();
      		cnt++;
      		for(int i = 0; i < 6; i++){
      			int tx = now.x + dx[i], ty = now.y + dy[i], tz = now.z + dz[i];
      			if(judge(tx, ty, tz)){
      				q.push(node(tx, ty, tz));
      				vis[tx][ty][tz] = 1;
      			}
      		}
      	}
      }
      int main(){
      	cin >> m >> n >> L >> T;
      	for(int z = 0; z < L; z++){
      		for(int x = 0; x < m; x++){
      			for(int y = 0; y < n; y++){
      				cin >> mp[x][y][z];
      			}
      		}
      	}
      	//bfs遍历
      	 for(int z = 0; z < L; z++){
      		for(int x = 0; x < m; x++){
      			for(int y = 0; y < n; y++){
      				if(!vis[x][y][z] && mp[x][y][z] == 1){
      					cnt = 0;
      					bfs(x, y, z);
      					if(cnt >= T){
      						sum += cnt;
      					}
      				}
      			}
      		}
      	}
      	 printf("%d", sum);
      	return 0;
      }